summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--android_webview/browser/browser_view_renderer.cc41
-rw-r--r--android_webview/browser/browser_view_renderer.h6
-rw-r--r--android_webview/browser/hardware_renderer.cc12
-rw-r--r--android_webview/browser/shared_renderer_state.cc64
-rw-r--r--android_webview/browser/shared_renderer_state.h48
-rw-r--r--android_webview/native/aw_contents.cc16
-rw-r--r--android_webview/native/aw_contents.h6
7 files changed, 106 insertions, 87 deletions
diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index 59c3038..6518f4f 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -68,11 +68,10 @@ void BrowserViewRenderer::CalculateTileMemoryPolicy() {
BrowserViewRenderer::BrowserViewRenderer(
BrowserViewRendererClient* client,
- SharedRendererState* shared_renderer_state,
content::WebContents* web_contents,
const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
: client_(client),
- shared_renderer_state_(shared_renderer_state),
+ shared_renderer_state_(ui_task_runner, this),
web_contents_(web_contents),
ui_task_runner_(ui_task_runner),
compositor_(NULL),
@@ -104,6 +103,15 @@ BrowserViewRenderer::~BrowserViewRenderer() {
// policy should have already been updated.
}
+SharedRendererState* BrowserViewRenderer::GetSharedRendererState() {
+ return &shared_renderer_state_;
+}
+
+bool BrowserViewRenderer::RequestDrawGL(jobject canvas,
+ bool wait_for_completion) {
+ return client_->RequestDrawGL(canvas, wait_for_completion);
+}
+
// This function updates the resource allocation in GlobalTileManager.
void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
DCHECK(ui_task_runner_->BelongsToCurrentThread());
@@ -212,7 +220,7 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
if (!compositor_)
return false;
- shared_renderer_state_->SetScrollOffset(last_on_draw_scroll_offset_);
+ shared_renderer_state_.SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
if (!hardware_enabled_) {
hardware_enabled_ = compositor_->InitializeHwDraw();
@@ -228,12 +236,12 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
TRACE_EVENT_INSTANT0("android_webview",
"EarlyOut_EmptyVisibleRect",
TRACE_EVENT_SCOPE_THREAD);
- shared_renderer_state_->SetForceInvalidateOnNextDrawGL(true);
+ shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(true);
return client_->RequestDrawGL(java_canvas, false);
}
ReturnResourceFromParent();
- if (shared_renderer_state_->HasCompositorFrame()) {
+ if (shared_renderer_state_.HasCompositorFrameOnUI()) {
TRACE_EVENT_INSTANT0("android_webview",
"EarlyOut_PreviousFrameUnconsumed",
TRACE_EVENT_SCOPE_THREAD);
@@ -245,7 +253,7 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
if (!frame.get())
return false;
- shared_renderer_state_->SetCompositorFrame(frame.Pass(), false);
+ shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), false);
GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
return client_->RequestDrawGL(java_canvas, false);
}
@@ -255,7 +263,8 @@ scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
RequestMemoryPolicy(new_policy);
compositor_->SetMemoryPolicy(memory_policy_);
- parent_draw_constraints_ = shared_renderer_state_->ParentDrawConstraints();
+ parent_draw_constraints_ =
+ shared_renderer_state_.GetParentDrawConstraintsOnUI();
gfx::Size surface_size(width_, height_);
gfx::Rect viewport(surface_size);
gfx::Rect clip = viewport;
@@ -289,11 +298,11 @@ void BrowserViewRenderer::UpdateParentDrawConstraints() {
// Post an invalidate if the parent draw constraints are stale and there is
// no pending invalidate.
bool needs_force_invalidate =
- shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL();
+ shared_renderer_state_.NeedsForceInvalidateOnNextDrawGLOnUI();
if (needs_force_invalidate ||
!parent_draw_constraints_.Equals(
- shared_renderer_state_->ParentDrawConstraints())) {
- shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
+ shared_renderer_state_.GetParentDrawConstraintsOnUI())) {
+ shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(false);
EnsureContinuousInvalidation(true, needs_force_invalidate);
}
}
@@ -312,7 +321,7 @@ void BrowserViewRenderer::ReturnUnusedResource(
void BrowserViewRenderer::ReturnResourceFromParent() {
cc::CompositorFrameAck frame_ack;
- shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);
+ shared_renderer_state_.SwapReturnedResourcesOnUI(&frame_ack.resources);
if (compositor_ && !frame_ack.resources.empty()) {
compositor_->ReturnResources(frame_ack);
}
@@ -445,9 +454,11 @@ void BrowserViewRenderer::OnDetachedFromWindow() {
void BrowserViewRenderer::ReleaseHardware() {
DCHECK(hardware_enabled_);
- ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
+ // TODO(hush): do this in somewhere else. Either in hardware render or in
+ // shared renderer state.
+ ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());
ReturnResourceFromParent();
- DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
+ DCHECK(shared_renderer_state_.ReturnedResourcesEmpty());
if (compositor_) {
compositor_->ReleaseHwDraw();
@@ -744,10 +755,10 @@ void BrowserViewRenderer::FallbackTickFired() {
if (compositor_needs_continuous_invalidate_ && compositor_) {
if (hardware_enabled_) {
ReturnResourceFromParent();
- ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
+ ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());
scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
if (frame.get()) {
- shared_renderer_state_->SetCompositorFrame(frame.Pass(), true);
+ shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), true);
}
} else {
ForceFakeCompositeSW();
diff --git a/android_webview/browser/browser_view_renderer.h b/android_webview/browser/browser_view_renderer.h
index 1fc5650..95ec894 100644
--- a/android_webview/browser/browser_view_renderer.h
+++ b/android_webview/browser/browser_view_renderer.h
@@ -61,12 +61,14 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient,
BrowserViewRenderer(
BrowserViewRendererClient* client,
- SharedRendererState* shared_renderer_state,
content::WebContents* web_contents,
const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
virtual ~BrowserViewRenderer();
+ SharedRendererState* GetSharedRendererState();
+ bool RequestDrawGL(jobject canvas, bool wait_for_completion);
+
// Main handler for view drawing: performs a SW draw immediately, or sets up
// a subsequent GL Draw (via BrowserViewRendererClient::RequestDrawGL) and
// returns true. A false return value indicates nothing was or will be drawn.
@@ -188,7 +190,7 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient,
std::string ToString() const;
BrowserViewRendererClient* client_;
- SharedRendererState* shared_renderer_state_;
+ SharedRendererState shared_renderer_state_;
content::WebContents* web_contents_;
scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
diff --git a/android_webview/browser/hardware_renderer.cc b/android_webview/browser/hardware_renderer.cc
index 3511bb8..546169e 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -125,7 +125,7 @@ HardwareRenderer::~HardwareRenderer() {
resource_collection_->SetClient(NULL);
// Reset draw constraints.
- shared_renderer_state_->UpdateDrawConstraints(
+ shared_renderer_state_->UpdateDrawConstraintsOnRT(
ParentCompositorDrawConstraints());
}
@@ -139,12 +139,12 @@ void HardwareRenderer::DidBeginMainFrame() {
}
void HardwareRenderer::CommitFrame() {
- scroll_offset_ = shared_renderer_state_->GetScrollOffset();
+ scroll_offset_ = shared_renderer_state_->GetScrollOffsetOnRT();
if (committed_frame_.get()) {
TRACE_EVENT_INSTANT0("android_webview",
"EarlyOut_PreviousFrameUnconsumed",
TRACE_EVENT_SCOPE_THREAD);
- shared_renderer_state_->DidSkipCommitFrame();
+ shared_renderer_state_->DidSkipCommitFrameOnRT();
return;
}
@@ -207,7 +207,7 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
DLOG(WARNING) << "EGLContextChanged";
SetFrameData();
- if (shared_renderer_state_->ForceCommit()) {
+ if (shared_renderer_state_->ForceCommitOnRT()) {
CommitFrame();
SetFrameData();
}
@@ -223,7 +223,7 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
draw_info->is_layer, transform, gfx::Rect(viewport_));
draw_constraints_ = draw_constraints;
- shared_renderer_state_->PostExternalDrawConstraintsToChildCompositor(
+ shared_renderer_state_->PostExternalDrawConstraintsToChildCompositorOnRT(
draw_constraints);
if (!delegated_layer_.get())
@@ -265,7 +265,7 @@ void HardwareRenderer::UnusedResourcesAreAvailable() {
cc::ReturnedResourceArray returned_resources;
resource_collection_->TakeUnusedResourcesForChildCompositor(
&returned_resources);
- shared_renderer_state_->InsertReturnedResources(returned_resources);
+ shared_renderer_state_->InsertReturnedResourcesOnRT(returned_resources);
}
} // namespace android_webview
diff --git a/android_webview/browser/shared_renderer_state.cc b/android_webview/browser/shared_renderer_state.cc
index 0de8371..6cb417b 100644
--- a/android_webview/browser/shared_renderer_state.cc
+++ b/android_webview/browser/shared_renderer_state.cc
@@ -4,7 +4,7 @@
#include "android_webview/browser/shared_renderer_state.h"
-#include "android_webview/browser/browser_view_renderer_client.h"
+#include "android_webview/browser/browser_view_renderer.h"
#include "base/bind.h"
#include "base/lazy_instance.h"
#include "base/location.h"
@@ -16,7 +16,7 @@ namespace internal {
class RequestDrawGLTracker {
public:
RequestDrawGLTracker();
- bool ShouldRequestOnNoneUiThread(SharedRendererState* state);
+ bool ShouldRequestOnNonUiThread(SharedRendererState* state);
bool ShouldRequestOnUiThread(SharedRendererState* state);
void DidRequestOnUiThread();
void ResetPending();
@@ -31,7 +31,7 @@ RequestDrawGLTracker::RequestDrawGLTracker()
: pending_ui_(NULL), pending_non_ui_(NULL) {
}
-bool RequestDrawGLTracker::ShouldRequestOnNoneUiThread(
+bool RequestDrawGLTracker::ShouldRequestOnNonUiThread(
SharedRendererState* state) {
base::AutoLock lock(lock_);
if (pending_ui_ || pending_non_ui_)
@@ -68,16 +68,16 @@ base::LazyInstance<internal::RequestDrawGLTracker> g_request_draw_gl_tracker =
}
SharedRendererState::SharedRendererState(
- scoped_refptr<base::MessageLoopProxy> ui_loop,
- BrowserViewRendererClient* client)
+ const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop,
+ BrowserViewRenderer* browser_view_renderer)
: ui_loop_(ui_loop),
- client_on_ui_(client),
+ browser_view_renderer_(browser_view_renderer),
force_commit_(false),
inside_hardware_release_(false),
needs_force_invalidate_on_next_draw_gl_(false),
weak_factory_on_ui_thread_(this) {
DCHECK(ui_loop_->BelongsToCurrentThread());
- DCHECK(client_on_ui_);
+ DCHECK(browser_view_renderer_);
ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
ResetRequestDrawGLCallback();
}
@@ -92,7 +92,7 @@ void SharedRendererState::ClientRequestDrawGL() {
return;
ClientRequestDrawGLOnUIThread();
} else {
- if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNoneUiThread(this))
+ if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNonUiThread(this))
return;
base::Closure callback;
{
@@ -119,7 +119,7 @@ void SharedRendererState::ResetRequestDrawGLCallback() {
void SharedRendererState::ClientRequestDrawGLOnUIThread() {
DCHECK(ui_loop_->BelongsToCurrentThread());
ResetRequestDrawGLCallback();
- if (!client_on_ui_->RequestDrawGL(NULL, false)) {
+ if (!browser_view_renderer_->RequestDrawGL(NULL, false)) {
g_request_draw_gl_tracker.Get().ResetPending();
LOG(ERROR) << "Failed to request GL process. Deadlock likely";
}
@@ -127,26 +127,27 @@ void SharedRendererState::ClientRequestDrawGLOnUIThread() {
void SharedRendererState::UpdateParentDrawConstraintsOnUIThread() {
DCHECK(ui_loop_->BelongsToCurrentThread());
- client_on_ui_->UpdateParentDrawConstraints();
+ browser_view_renderer_->UpdateParentDrawConstraints();
}
-void SharedRendererState::SetScrollOffset(gfx::Vector2d scroll_offset) {
+void SharedRendererState::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
base::AutoLock lock(lock_);
scroll_offset_ = scroll_offset;
}
-gfx::Vector2d SharedRendererState::GetScrollOffset() {
+gfx::Vector2d SharedRendererState::GetScrollOffsetOnRT() {
base::AutoLock lock(lock_);
return scroll_offset_;
}
-bool SharedRendererState::HasCompositorFrame() const {
+bool SharedRendererState::HasCompositorFrameOnUI() const {
base::AutoLock lock(lock_);
return compositor_frame_.get();
}
-void SharedRendererState::SetCompositorFrame(
- scoped_ptr<cc::CompositorFrame> frame, bool force_commit) {
+void SharedRendererState::SetCompositorFrameOnUI(
+ scoped_ptr<cc::CompositorFrame> frame,
+ bool force_commit) {
base::AutoLock lock(lock_);
DCHECK(!compositor_frame_.get());
compositor_frame_ = frame.Pass();
@@ -158,12 +159,12 @@ scoped_ptr<cc::CompositorFrame> SharedRendererState::PassCompositorFrame() {
return compositor_frame_.Pass();
}
-bool SharedRendererState::ForceCommit() const {
+bool SharedRendererState::ForceCommitOnRT() const {
base::AutoLock lock(lock_);
return force_commit_;
}
-bool SharedRendererState::UpdateDrawConstraints(
+bool SharedRendererState::UpdateDrawConstraintsOnRT(
const ParentCompositorDrawConstraints& parent_draw_constraints) {
base::AutoLock lock(lock_);
if (needs_force_invalidate_on_next_draw_gl_ ||
@@ -175,9 +176,9 @@ bool SharedRendererState::UpdateDrawConstraints(
return false;
}
-void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
+void SharedRendererState::PostExternalDrawConstraintsToChildCompositorOnRT(
const ParentCompositorDrawConstraints& parent_draw_constraints) {
- if (UpdateDrawConstraints(parent_draw_constraints)) {
+ if (UpdateDrawConstraintsOnRT(parent_draw_constraints)) {
// No need to hold the lock_ during the post task.
ui_loop_->PostTask(
FROM_HERE,
@@ -186,32 +187,31 @@ void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
}
}
-void SharedRendererState::DidSkipCommitFrame() {
- ui_loop_->PostTask(
- FROM_HERE,
- base::Bind(&SharedRendererState::DidSkipCommitFrameOnUIThread,
- ui_thread_weak_ptr_));
+void SharedRendererState::DidSkipCommitFrameOnRT() {
+ ui_loop_->PostTask(FROM_HERE,
+ base::Bind(&SharedRendererState::DidSkipCommitFrameOnUI,
+ ui_thread_weak_ptr_));
}
-void SharedRendererState::DidSkipCommitFrameOnUIThread() {
+void SharedRendererState::DidSkipCommitFrameOnUI() {
DCHECK(ui_loop_->BelongsToCurrentThread());
- client_on_ui_->DidSkipCommitFrame();
+ browser_view_renderer_->DidSkipCommitFrame();
}
-const ParentCompositorDrawConstraints
-SharedRendererState::ParentDrawConstraints() const {
+ParentCompositorDrawConstraints
+SharedRendererState::GetParentDrawConstraintsOnUI() const {
base::AutoLock lock(lock_);
return parent_draw_constraints_;
}
-void SharedRendererState::SetForceInvalidateOnNextDrawGL(
+void SharedRendererState::SetForceInvalidateOnNextDrawGLOnUI(
bool needs_force_invalidate_on_next_draw_gl) {
base::AutoLock lock(lock_);
needs_force_invalidate_on_next_draw_gl_ =
needs_force_invalidate_on_next_draw_gl;
}
-bool SharedRendererState::NeedsForceInvalidateOnNextDrawGL() const {
+bool SharedRendererState::NeedsForceInvalidateOnNextDrawGLOnUI() const {
base::AutoLock lock(lock_);
return needs_force_invalidate_on_next_draw_gl_;
}
@@ -226,14 +226,14 @@ bool SharedRendererState::IsInsideHardwareRelease() const {
return inside_hardware_release_;
}
-void SharedRendererState::InsertReturnedResources(
+void SharedRendererState::InsertReturnedResourcesOnRT(
const cc::ReturnedResourceArray& resources) {
base::AutoLock lock(lock_);
returned_resources_.insert(
returned_resources_.end(), resources.begin(), resources.end());
}
-void SharedRendererState::SwapReturnedResources(
+void SharedRendererState::SwapReturnedResourcesOnUI(
cc::ReturnedResourceArray* resources) {
DCHECK(resources->empty());
base::AutoLock lock(lock_);
diff --git a/android_webview/browser/shared_renderer_state.h b/android_webview/browser/shared_renderer_state.h
index 29d05c2..270d318 100644
--- a/android_webview/browser/shared_renderer_state.h
+++ b/android_webview/browser/shared_renderer_state.h
@@ -8,7 +8,7 @@
#include "android_webview/browser/parent_compositor_draw_constraints.h"
#include "base/cancelable_callback.h"
#include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
#include "base/synchronization/lock.h"
#include "cc/output/compositor_frame.h"
#include "cc/output/compositor_frame_ack.h"
@@ -21,44 +21,48 @@ namespace internal {
class RequestDrawGLTracker;
}
-class BrowserViewRendererClient;
+class BrowserViewRenderer;
class InsideHardwareReleaseReset;
// This class is used to pass data between UI thread and RenderThread.
+// TODO(hush): this class should own HardwareRenderer.
class SharedRendererState {
public:
- SharedRendererState(scoped_refptr<base::MessageLoopProxy> ui_loop,
- BrowserViewRendererClient* client);
+ SharedRendererState(
+ const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop,
+ BrowserViewRenderer* browser_view_renderer);
~SharedRendererState();
void ClientRequestDrawGL();
void DidDrawGLProcess();
- void SetScrollOffset(gfx::Vector2d scroll_offset);
- gfx::Vector2d GetScrollOffset();
+ void SetScrollOffsetOnUI(gfx::Vector2d scroll_offset);
+ gfx::Vector2d GetScrollOffsetOnRT();
- bool HasCompositorFrame() const;
- void SetCompositorFrame(scoped_ptr<cc::CompositorFrame> frame,
- bool force_commit);
+ bool HasCompositorFrameOnUI() const;
+ void SetCompositorFrameOnUI(scoped_ptr<cc::CompositorFrame> frame,
+ bool force_commit);
+ // Right now this method is called on both UI and RT.
+ // TODO(hush): Make it only called from RT.
scoped_ptr<cc::CompositorFrame> PassCompositorFrame();
- bool ForceCommit() const;
+ bool ForceCommitOnRT() const;
+ // TODO(hush): this will be private after DrawGL moves to this class.
bool IsInsideHardwareRelease() const;
// Returns true if the draw constraints are updated.
- bool UpdateDrawConstraints(
+ bool UpdateDrawConstraintsOnRT(
const ParentCompositorDrawConstraints& parent_draw_constraints);
- void PostExternalDrawConstraintsToChildCompositor(
+ void PostExternalDrawConstraintsToChildCompositorOnRT(
const ParentCompositorDrawConstraints& parent_draw_constraints);
- void DidSkipCommitFrame();
+ ParentCompositorDrawConstraints GetParentDrawConstraintsOnUI() const;
- const ParentCompositorDrawConstraints ParentDrawConstraints() const;
-
- void SetForceInvalidateOnNextDrawGL(
+ void DidSkipCommitFrameOnRT();
+ void SetForceInvalidateOnNextDrawGLOnUI(
bool needs_force_invalidate_on_next_draw_gl);
- bool NeedsForceInvalidateOnNextDrawGL() const;
+ bool NeedsForceInvalidateOnNextDrawGLOnUI() const;
- void InsertReturnedResources(const cc::ReturnedResourceArray& resources);
- void SwapReturnedResources(cc::ReturnedResourceArray* resources);
+ void InsertReturnedResourcesOnRT(const cc::ReturnedResourceArray& resources);
+ void SwapReturnedResourcesOnUI(cc::ReturnedResourceArray* resources);
bool ReturnedResourcesEmpty() const;
private:
@@ -68,11 +72,11 @@ class SharedRendererState {
void ResetRequestDrawGLCallback();
void ClientRequestDrawGLOnUIThread();
void UpdateParentDrawConstraintsOnUIThread();
- void DidSkipCommitFrameOnUIThread();
+ void DidSkipCommitFrameOnUI();
void SetInsideHardwareRelease(bool inside);
- scoped_refptr<base::MessageLoopProxy> ui_loop_;
- BrowserViewRendererClient* client_on_ui_;
+ scoped_refptr<base::SingleThreadTaskRunner> ui_loop_;
+ BrowserViewRenderer* browser_view_renderer_;
base::WeakPtr<SharedRendererState> ui_thread_weak_ptr_;
base::CancelableClosure request_draw_gl_cancelable_closure_;
diff --git a/android_webview/native/aw_contents.cc b/android_webview/native/aw_contents.cc
index fb7b2e4..1994e89 100644
--- a/android_webview/native/aw_contents.cc
+++ b/android_webview/native/aw_contents.cc
@@ -160,14 +160,11 @@ AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
AwContents::AwContents(scoped_ptr<WebContents> web_contents)
: web_contents_(web_contents.Pass()),
- shared_renderer_state_(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- this),
browser_view_renderer_(
this,
- &shared_renderer_state_,
web_contents_.get(),
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
+ shared_renderer_state_(browser_view_renderer_.GetSharedRendererState()),
renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
icon_helper_.reset(new IconHelper(web_contents_.get()));
@@ -343,6 +340,7 @@ jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
return reinterpret_cast<intptr_t>(this);
}
+// TODO(hush): move this function to SharedRendererState.
void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
if (draw_info->mode == AwDrawGLInfo::kModeSync) {
if (hardware_renderer_)
@@ -375,10 +373,10 @@ void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
// corruption.
if (draw_info->mode == AwDrawGLInfo::kModeProcess ||
draw_info->mode == AwDrawGLInfo::kModeProcessNoContext) {
- shared_renderer_state_.DidDrawGLProcess();
+ shared_renderer_state_->DidDrawGLProcess();
}
- if (shared_renderer_state_.IsInsideHardwareRelease()) {
+ if (shared_renderer_state_->IsInsideHardwareRelease()) {
hardware_renderer_.reset();
// Flush the idle queue in tear down.
DeferredGpuCommandService::GetInstance()->PerformAllIdleWork();
@@ -393,7 +391,7 @@ void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
}
if (!hardware_renderer_) {
- hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
+ hardware_renderer_.reset(new HardwareRenderer(shared_renderer_state_));
hardware_renderer_->CommitFrame();
}
@@ -888,7 +886,7 @@ void AwContents::InitializeHardwareDrawIfNeeded() {
base::AutoLock lock(render_thread_lock_);
if (renderer_manager_key_ == manager->NullKey()) {
- renderer_manager_key_ = manager->PushBack(&shared_renderer_state_);
+ renderer_manager_key_ = manager->PushBack(shared_renderer_state_);
DeferredGpuCommandService::SetInstance();
}
}
@@ -900,7 +898,7 @@ void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
}
void AwContents::ReleaseHardwareDrawIfNeeded() {
- InsideHardwareReleaseReset inside_reset(&shared_renderer_state_);
+ InsideHardwareReleaseReset inside_reset(shared_renderer_state_);
JNIEnv* env = AttachCurrentThread();
ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
diff --git a/android_webview/native/aw_contents.h b/android_webview/native/aw_contents.h
index f350b73..7ada436 100644
--- a/android_webview/native/aw_contents.h
+++ b/android_webview/native/aw_contents.h
@@ -239,8 +239,12 @@ class AwContents : public FindHelper::Listener,
scoped_ptr<FindHelper> find_helper_;
scoped_ptr<IconHelper> icon_helper_;
scoped_ptr<AwContents> pending_contents_;
- SharedRendererState shared_renderer_state_;
BrowserViewRenderer browser_view_renderer_;
+ // SharedRendererState is owned by BrowserViewRenderer.
+ // So keep a raw pointer here.
+ SharedRendererState* shared_renderer_state_;
+ // TODO(hush): hardware renderer will be owned by SharedRendererState,
+ // after DrawGL is moved to SharedRendererState.
scoped_ptr<HardwareRenderer> hardware_renderer_;
scoped_ptr<AwPdfExporter> pdf_exporter_;
scoped_ptr<PermissionRequestHandler> permission_request_handler_;
generated by cgit v1.1 at 2025-03-10 13:41:44 +0000