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"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/hardware_renderer.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
+#include "android_webview/browser/shared_renderer_state_client.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_argument.h"
 
 namespace android_webview {
 
 namespace internal {
@@ skipping 56 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)
+    SharedRendererStateClient* client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop)
     : ui_loop_(ui_loop),
-      browser_view_renderer_(browser_view_renderer),
+      client_(client),
       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_);
+  DCHECK(client_);
   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 27 matching lines @@
   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());
   ResetRequestDrawGLCallback();
   g_request_draw_gl_tracker.Get().SetQueuedFunctorOnUi(this);
-  if (!browser_view_renderer_->RequestDrawGL(false)) {
+  if (!client_->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());
-  browser_view_renderer_->UpdateParentDrawConstraints();
+  client_->DrawConstraintsUpdated(GetParentDrawConstraintsOnUI());
 }
 
 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_;
 }
 
-void SharedRendererState::SetCompositorFrameOnUI(scoped_ptr<ChildFrame> frame) {
+void SharedRendererState::SetFrameOnUI(scoped_ptr<ChildFrame> frame) {
   base::AutoLock lock(lock_);
   DCHECK(!child_frame_.get());
   child_frame_ = std::move(frame);
 }
 
-scoped_ptr<ChildFrame> SharedRendererState::PassCompositorFrameOnRT() {
+scoped_ptr<ChildFrame> SharedRendererState::PassFrameOnRT() {
   base::AutoLock lock(lock_);
   hardware_renderer_has_frame_ =
       hardware_renderer_has_frame_ || child_frame_.get();
   return std::move(child_frame_);
 }
 
 scoped_ptr<ChildFrame> SharedRendererState::PassUncommittedFrameOnUI() {
   base::AutoLock lock(lock_);
   return std::move(child_frame_);
 }
@@ skipping 122 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::DeleteHardwareRendererOnUI() {
+  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();
+  client_->DetachFunctorFromView();
+  bool hardware_initialized = client_->IsHardwareEnabled();

[boliu, 2016/03/24 17:34:45]

This used to call BVR clean up, so was checking with BVR. Now feels like this
should just be an SRS internal bool state, of whether there is anything that
needs to be cleaned up on RT, ie if HR has been created.

   // 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);
+    bool draw_functor_succeeded = client_->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);
+    client_->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/24 17:34:45]

don't need level arg

+  DeleteHardwareRendererOnUI();
+}
+
 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