forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
render_thread_manager.h
131 lines (109 loc) · 4.66 KB
/
render_thread_manager.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ANDROID_WEBVIEW_BROWSER_RENDER_THREAD_MANAGER_H_
#define ANDROID_WEBVIEW_BROWSER_RENDER_THREAD_MANAGER_H_
#include <map>
#include "android_webview/browser/compositor_frame_consumer.h"
#include "android_webview/browser/gl_view_renderer_manager.h"
#include "android_webview/browser/parent_compositor_draw_constraints.h"
#include "base/cancelable_callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/single_thread_task_runner.h"
#include "base/synchronization/lock.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/vector2d.h"
struct AwDrawGLInfo;
namespace android_webview {
namespace internal {
class RequestInvokeGLTracker;
}
class RenderThreadManagerClient;
class ChildFrame;
class CompositorFrameProducer;
class HardwareRenderer;
class InsideHardwareReleaseReset;
struct CompositorID;
// This class is used to pass data between UI thread and RenderThread.
class RenderThreadManager : public CompositorFrameConsumer {
public:
RenderThreadManager(
RenderThreadManagerClient* client,
const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop);
~RenderThreadManager() override;
// This function can be called from any thread.
void ClientRequestInvokeGL(bool for_idle);
// CompositorFrameConsumer methods.
void SetCompositorFrameProducer(
CompositorFrameProducer* compositor_frame_producer) override;
void SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) override;
void SetFrameOnUI(
std::unique_ptr<ChildFrame> frame,
const scoped_refptr<content::SynchronousCompositor::FrameFuture>&
frame_future) override;
void InitializeHardwareDrawIfNeededOnUI() override;
ParentCompositorDrawConstraints GetParentDrawConstraintsOnUI() const override;
void SwapReturnedResourcesOnUI(
ReturnedResourcesMap* returned_resource_map) override;
bool ReturnedResourcesEmptyOnUI() const override;
std::unique_ptr<ChildFrame> PassUncommittedFrameOnUI() override;
bool HasFrameOnUI() const override;
void DeleteHardwareRendererOnUI() override;
// RT thread methods.
gfx::Vector2d GetScrollOffsetOnRT();
std::unique_ptr<ChildFrame> PassFrameOnRT();
void DrawGL(AwDrawGLInfo* draw_info);
void PostExternalDrawConstraintsToChildCompositorOnRT(
const ParentCompositorDrawConstraints& parent_draw_constraints);
void InsertReturnedResourcesOnRT(const cc::ReturnedResourceArray& resources,
const CompositorID& compositor_id,
uint32_t compositor_frame_sink_id);
private:
friend class internal::RequestInvokeGLTracker;
class InsideHardwareReleaseReset {
public:
explicit InsideHardwareReleaseReset(
RenderThreadManager* render_thread_manager);
~InsideHardwareReleaseReset();
private:
RenderThreadManager* render_thread_manager_;
};
static std::unique_ptr<ChildFrame> GetSynchronousCompositorFrame(
scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future,
std::unique_ptr<ChildFrame> child_frame);
// RT thread method.
void DidInvokeGLProcess();
bool HasFrameForHardwareRendererOnRT() const;
// UI thread methods.
void ResetRequestInvokeGLCallback();
void ClientRequestInvokeGLOnUI();
void UpdateParentDrawConstraintsOnUI();
bool IsInsideHardwareRelease() const;
void SetInsideHardwareRelease(bool inside);
// Accessed by UI thread.
scoped_refptr<base::SingleThreadTaskRunner> ui_loop_;
RenderThreadManagerClient* const client_;
CompositorFrameProducer* compositor_frame_producer_;
base::WeakPtr<RenderThreadManager> ui_thread_weak_ptr_;
base::CancelableClosure request_draw_gl_cancelable_closure_;
// Accessed by RT thread.
std::unique_ptr<HardwareRenderer> hardware_renderer_;
// This is accessed by both UI and RT now. TODO(hush): move to RT only.
GLViewRendererManager::Key renderer_manager_key_;
// Accessed by both UI and RT thread.
mutable base::Lock lock_;
bool hardware_renderer_has_frame_;
gfx::Vector2d scroll_offset_;
std::unique_ptr<ChildFrame> child_frame_;
const bool async_on_draw_hardware_;
scoped_refptr<content::SynchronousCompositor::FrameFuture> frame_future_;
bool inside_hardware_release_;
ParentCompositorDrawConstraints parent_draw_constraints_;
ReturnedResourcesMap returned_resources_map_;
base::Closure request_draw_gl_closure_;
base::WeakPtrFactory<RenderThreadManager> weak_factory_on_ui_thread_;
DISALLOW_COPY_AND_ASSIGN(RenderThreadManager);
};
} // namespace android_webview
#endif // ANDROID_WEBVIEW_BROWSER_RENDER_THREAD_MANAGER_H_