Move SharedRendererState ownership to AwContents

android_webview/browser/shared_renderer_state.cc

 // 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.
 
 #include "android_webview/browser/shared_renderer_state.h"
 
 #include <utility>
 
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
@@ skipping 69 matching lines @@
 }  // namespace internal
 
 namespace {
 
 base::LazyInstance<internal::RequestDrawGLTracker> g_request_draw_gl_tracker =
     LAZY_INSTANCE_INITIALIZER;
 
 }
 
 SharedRendererState::SharedRendererState(
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop,
-    BrowserViewRenderer* browser_view_renderer)
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop)
     : ui_loop_(ui_loop),
-      browser_view_renderer_(browser_view_renderer),
+      browser_view_renderer_(nullptr),
       renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()),
       hardware_renderer_has_frame_(false),
       inside_hardware_release_(false),
       weak_factory_on_ui_thread_(this) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
-  DCHECK(browser_view_renderer_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
   ResetRequestDrawGLCallback();
 }
 
 SharedRendererState::~SharedRendererState() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!hardware_renderer_.get());
 }
 
 void SharedRendererState::ClientRequestDrawGL(bool for_idle) {
@@ skipping 25 matching lines @@
 void SharedRendererState::ResetRequestDrawGLCallback() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   base::AutoLock lock(lock_);
   request_draw_gl_cancelable_closure_.Reset(base::Bind(
       &SharedRendererState::ClientRequestDrawGLOnUI, base::Unretained(this)));
   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 }
 
 void SharedRendererState::ClientRequestDrawGLOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
+  DCHECK(browser_view_renderer_);
   ResetRequestDrawGLCallback();
   g_request_draw_gl_tracker.Get().SetQueuedFunctorOnUi(this);
   if (!browser_view_renderer_->RequestDrawGL(false)) {
     g_request_draw_gl_tracker.Get().ResetPending();
     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
   }
 }
 
 void SharedRendererState::UpdateParentDrawConstraintsOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
+  DCHECK(browser_view_renderer_);
   browser_view_renderer_->UpdateParentDrawConstraints();
 }
 
+void SharedRendererState::SetBrowserViewRendererOnUI(
+    BrowserViewRenderer* browser_view_renderer) {
+  DCHECK(ui_loop_->BelongsToCurrentThread());
+  browser_view_renderer_ = browser_view_renderer;
+}
+
 void SharedRendererState::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
   base::AutoLock lock(lock_);
   scroll_offset_ = scroll_offset;
 }
 
 gfx::Vector2d SharedRendererState::GetScrollOffsetOnRT() {
   base::AutoLock lock(lock_);
   return scroll_offset_;
 }
 
@@ skipping 139 matching lines @@
     if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
       DeferredGpuCommandService::GetInstance()->PerformIdleWork(true);
     }
     return;
   }
 
   hardware_renderer_->DrawGL(draw_info, state_restore);
   DeferredGpuCommandService::GetInstance()->PerformIdleWork(false);
 }
 
-void SharedRendererState::ReleaseHardwareDrawIfNeededOnUI() {
-  ReleaseCompositorResourcesIfNeededOnUI(true);
-}
+void SharedRendererState::ReleaseCompositorResourcesIfNeededOnUI() {

[boliu, 2016/03/23 20:42:32]

DeleteHardwareRendererOnUIThread actually sounds better

[Tobias Sargeant, 2016/03/24 16:53:05]

Done.

+  DCHECK(ui_loop_->BelongsToCurrentThread());
 
-void SharedRendererState::DeleteHardwareRendererOnUI() {
-  ReleaseCompositorResourcesIfNeededOnUI(false);
-}
-
-void SharedRendererState::ReleaseCompositorResourcesIfNeededOnUI(
-    bool release_hardware_draw) {
-  DCHECK(ui_loop_->BelongsToCurrentThread());
   InsideHardwareReleaseReset auto_inside_hardware_release_reset(this);
 
   browser_view_renderer_->DetachFunctorFromView();
   bool hardware_initialized = browser_view_renderer_->hardware_enabled();
   // If the WebView gets onTrimMemory >= MODERATE twice in a row, the 2nd
   // onTrimMemory will result in an unnecessary Render Thread DrawGL call.
   if (hardware_initialized) {
     bool draw_functor_succeeded = browser_view_renderer_->RequestDrawGL(true);
     if (!draw_functor_succeeded) {
       LOG(ERROR) << "Unable to free GL resources. Has the Window leaked?";
       // Calling release on wrong thread intentionally.
       AwDrawGLInfo info;
       info.mode = AwDrawGLInfo::kModeProcess;
       DrawGL(&info);
     }
-
-    if (release_hardware_draw)
-      browser_view_renderer_->ReleaseHardware();
   }
 
   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
 
   {
     base::AutoLock lock(lock_);
     if (renderer_manager_key_ != manager->NullKey()) {
       manager->Remove(renderer_manager_key_);
       renderer_manager_key_ = manager->NullKey();
     }
   }
 
   if (hardware_initialized) {
     // Flush any invoke functors that's caused by ReleaseHardware.
     browser_view_renderer_->RequestDrawGL(true);
   }
 }
 
 bool SharedRendererState::HasFrameOnUI() const {
   base::AutoLock lock(lock_);
   return hardware_renderer_has_frame_ || child_frame_.get();
 }
 
+void SharedRendererState::TrimMemoryOnUI(int level) {

[boliu, 2016/03/23 20:42:32]

The level check got dropped?

[Tobias Sargeant, 2016/03/24 16:53:05]

Done. Deciding what to trim and when moved to AwContents.

+  ReleaseCompositorResourcesIfNeededOnUI();
+}
+
 void SharedRendererState::InitializeHardwareDrawIfNeededOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
 
   base::AutoLock lock(lock_);
   if (renderer_manager_key_ == manager->NullKey()) {
     renderer_manager_key_ = manager->PushBack(this);
   }
 }
 
 SharedRendererState::InsideHardwareReleaseReset::InsideHardwareReleaseReset(
     SharedRendererState* shared_renderer_state)
     : shared_renderer_state_(shared_renderer_state) {
   DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
   shared_renderer_state_->SetInsideHardwareRelease(true);
 }
 
 SharedRendererState::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
   shared_renderer_state_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview