Rename SharedRendererState to RenderThreadManager

android_webview/browser/render_thread_manager.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 "android_webview/browser/render_thread_manager.h"
 
 #include <utility>
 
 #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/render_thread_manager_client.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 {
 
 class RequestDrawGLTracker {
  public:
   RequestDrawGLTracker();
-  bool ShouldRequestOnNonUiThread(SharedRendererState* state);
-  bool ShouldRequestOnUiThread(SharedRendererState* state);
+  bool ShouldRequestOnNonUiThread(RenderThreadManager* state);
+  bool ShouldRequestOnUiThread(RenderThreadManager* state);
   void ResetPending();
-  void SetQueuedFunctorOnUi(SharedRendererState* state);
+  void SetQueuedFunctorOnUi(RenderThreadManager* state);
 
  private:
   base::Lock lock_;
-  SharedRendererState* pending_ui_;
-  SharedRendererState* pending_non_ui_;
+  RenderThreadManager* pending_ui_;
+  RenderThreadManager* pending_non_ui_;
 };
 
 RequestDrawGLTracker::RequestDrawGLTracker()
     : pending_ui_(NULL), pending_non_ui_(NULL) {
 }
 
 bool RequestDrawGLTracker::ShouldRequestOnNonUiThread(
-    SharedRendererState* state) {
+    RenderThreadManager* state) {
   base::AutoLock lock(lock_);
   if (pending_ui_ || pending_non_ui_)
     return false;
   pending_non_ui_ = state;
   return true;
 }
 
-bool RequestDrawGLTracker::ShouldRequestOnUiThread(SharedRendererState* state) {
+bool RequestDrawGLTracker::ShouldRequestOnUiThread(RenderThreadManager* state) {
   base::AutoLock lock(lock_);
   if (pending_non_ui_) {
     pending_non_ui_->ResetRequestDrawGLCallback();
     pending_non_ui_ = NULL;
   }
   // At this time, we could have already called RequestDrawGL on the UI thread,
   // but the corresponding GL mode process hasn't happened yet. In this case,
   // don't schedule another requestDrawGL on the UI thread.
   if (pending_ui_)
     return false;
   pending_ui_ = state;
   return true;
 }
 
 void RequestDrawGLTracker::ResetPending() {
   base::AutoLock lock(lock_);
   pending_non_ui_ = NULL;
   pending_ui_ = NULL;
 }
 
-void RequestDrawGLTracker::SetQueuedFunctorOnUi(SharedRendererState* state) {
+void RequestDrawGLTracker::SetQueuedFunctorOnUi(RenderThreadManager* state) {
   base::AutoLock lock(lock_);
   DCHECK(state);
   pending_ui_ = state;
   pending_non_ui_ = NULL;
 }
 
 }  // namespace internal
 
 namespace {
 
 base::LazyInstance<internal::RequestDrawGLTracker> g_request_draw_gl_tracker =
     LAZY_INSTANCE_INITIALIZER;
 
 }
 
-SharedRendererState::SharedRendererState(
-    SharedRendererStateClient* client,
+RenderThreadManager::RenderThreadManager(
+    RenderThreadManagerClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_loop)
     : ui_loop_(ui_loop),
       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(client_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
   ResetRequestDrawGLCallback();
 }
 
-SharedRendererState::~SharedRendererState() {
+RenderThreadManager::~RenderThreadManager() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!hardware_renderer_.get());
 }
 
-void SharedRendererState::ClientRequestDrawGL(bool for_idle) {
+void RenderThreadManager::ClientRequestDrawGL(bool for_idle) {
   if (ui_loop_->BelongsToCurrentThread()) {
     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnUiThread(this))
       return;
     ClientRequestDrawGLOnUI();
   } else {
     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNonUiThread(this))
       return;
     base::Closure callback;
     {
       base::AutoLock lock(lock_);
       callback = request_draw_gl_closure_;
     }
     // 17ms is slightly longer than a frame, hoping that it will come
     // after the next frame so that the idle work is taken care off by
     // the next frame instead.
     ui_loop_->PostDelayedTask(
         FROM_HERE, callback,
         for_idle ? base::TimeDelta::FromMilliseconds(17) : base::TimeDelta());
   }
 }
 
-void SharedRendererState::DidDrawGLProcess() {
+void RenderThreadManager::DidDrawGLProcess() {
   g_request_draw_gl_tracker.Get().ResetPending();
 }
 
-void SharedRendererState::ResetRequestDrawGLCallback() {
+void RenderThreadManager::ResetRequestDrawGLCallback() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   base::AutoLock lock(lock_);
   request_draw_gl_cancelable_closure_.Reset(base::Bind(
-      &SharedRendererState::ClientRequestDrawGLOnUI, base::Unretained(this)));
+      &RenderThreadManager::ClientRequestDrawGLOnUI, base::Unretained(this)));
   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 }
 
-void SharedRendererState::ClientRequestDrawGLOnUI() {
+void RenderThreadManager::ClientRequestDrawGLOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   ResetRequestDrawGLCallback();
   g_request_draw_gl_tracker.Get().SetQueuedFunctorOnUi(this);
   if (!client_->RequestDrawGL(false)) {
     g_request_draw_gl_tracker.Get().ResetPending();
     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
   }
 }
 
-void SharedRendererState::UpdateParentDrawConstraintsOnUI() {
+void RenderThreadManager::UpdateParentDrawConstraintsOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   client_->OnParentDrawConstraintsUpdated();
 }
 
-void SharedRendererState::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
+void RenderThreadManager::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
   base::AutoLock lock(lock_);
   scroll_offset_ = scroll_offset;
 }
 
-gfx::Vector2d SharedRendererState::GetScrollOffsetOnRT() {
+gfx::Vector2d RenderThreadManager::GetScrollOffsetOnRT() {
   base::AutoLock lock(lock_);
   return scroll_offset_;
 }
 
-void SharedRendererState::SetFrameOnUI(std::unique_ptr<ChildFrame> frame) {
+void RenderThreadManager::SetFrameOnUI(std::unique_ptr<ChildFrame> frame) {
   base::AutoLock lock(lock_);
   DCHECK(!child_frame_.get());
   child_frame_ = std::move(frame);
 }
 
-std::unique_ptr<ChildFrame> SharedRendererState::PassFrameOnRT() {
+std::unique_ptr<ChildFrame> RenderThreadManager::PassFrameOnRT() {
   base::AutoLock lock(lock_);
   hardware_renderer_has_frame_ =
       hardware_renderer_has_frame_ || child_frame_.get();
   return std::move(child_frame_);
 }
 
-std::unique_ptr<ChildFrame> SharedRendererState::PassUncommittedFrameOnUI() {
+std::unique_ptr<ChildFrame> RenderThreadManager::PassUncommittedFrameOnUI() {
   base::AutoLock lock(lock_);
   return std::move(child_frame_);
 }
 
-void SharedRendererState::PostExternalDrawConstraintsToChildCompositorOnRT(
+void RenderThreadManager::PostExternalDrawConstraintsToChildCompositorOnRT(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
   {
     base::AutoLock lock(lock_);
     parent_draw_constraints_ = parent_draw_constraints;
   }
 
   // No need to hold the lock_ during the post task.
   ui_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&SharedRendererState::UpdateParentDrawConstraintsOnUI,
+      base::Bind(&RenderThreadManager::UpdateParentDrawConstraintsOnUI,
                  ui_thread_weak_ptr_));
 }
 
 ParentCompositorDrawConstraints
-SharedRendererState::GetParentDrawConstraintsOnUI() const {
+RenderThreadManager::GetParentDrawConstraintsOnUI() const {
   base::AutoLock lock(lock_);
   return parent_draw_constraints_;
 }
 
-void SharedRendererState::SetInsideHardwareRelease(bool inside) {
+void RenderThreadManager::SetInsideHardwareRelease(bool inside) {
   base::AutoLock lock(lock_);
   inside_hardware_release_ = inside;
 }
 
-bool SharedRendererState::IsInsideHardwareRelease() const {
+bool RenderThreadManager::IsInsideHardwareRelease() const {
   base::AutoLock lock(lock_);
   return inside_hardware_release_;
 }
 
-SharedRendererState::ReturnedResources::ReturnedResources()
+RenderThreadManager::ReturnedResources::ReturnedResources()
     : output_surface_id(0u) {}
 
-SharedRendererState::ReturnedResources::~ReturnedResources() {}
+RenderThreadManager::ReturnedResources::~ReturnedResources() {}
 
-void SharedRendererState::InsertReturnedResourcesOnRT(
+void RenderThreadManager::InsertReturnedResourcesOnRT(
     const cc::ReturnedResourceArray& resources,
     uint32_t compositor_id,
     uint32_t output_surface_id) {
   base::AutoLock lock(lock_);
   ReturnedResources& returned_resources =
       returned_resources_map_[compositor_id];
   if (returned_resources.output_surface_id != output_surface_id) {
     returned_resources.resources.clear();
   }
   returned_resources.resources.insert(returned_resources.resources.end(),
                                       resources.begin(), resources.end());
   returned_resources.output_surface_id = output_surface_id;
 }
 
-void SharedRendererState::SwapReturnedResourcesOnUI(
+void RenderThreadManager::SwapReturnedResourcesOnUI(
     ReturnedResourcesMap* returned_resource_map) {
   DCHECK(returned_resource_map->empty());
   base::AutoLock lock(lock_);
   returned_resource_map->swap(returned_resources_map_);
 }
 
-bool SharedRendererState::ReturnedResourcesEmptyOnUI() const {
+bool RenderThreadManager::ReturnedResourcesEmptyOnUI() const {
   base::AutoLock lock(lock_);
   return returned_resources_map_.empty();
 }
 
-void SharedRendererState::DrawGL(AwDrawGLInfo* draw_info) {
+void RenderThreadManager::DrawGL(AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "DrawFunctor");
   if (draw_info->mode == AwDrawGLInfo::kModeSync) {
     TRACE_EVENT_INSTANT0("android_webview", "kModeSync",
                          TRACE_EVENT_SCOPE_THREAD);
     if (hardware_renderer_)
       hardware_renderer_->CommitFrame();
     return;
   }
 
   // kModeProcessNoContext should never happen because we tear down hardware
@@ skipping 48 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::DeleteHardwareRendererOnUI() {
+void RenderThreadManager::DeleteHardwareRendererOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
 
   InsideHardwareReleaseReset auto_inside_hardware_release_reset(this);
 
   client_->DetachFunctorFromView();
 
   // If the WebView gets onTrimMemory >= MODERATE twice in a row, the 2nd
   // onTrimMemory will result in an unnecessary Render Thread DrawGL call.
   bool hardware_initialized = HasFrameOnUI();
   if (hardware_initialized) {
@@ skipping 16 matching lines @@
       renderer_manager_key_ = manager->NullKey();
     }
   }
 
   if (hardware_initialized) {
     // Flush any invoke functors that's caused by ReleaseHardware.
     client_->RequestDrawGL(true);
   }
 }
 
-bool SharedRendererState::HasFrameOnUI() const {
+bool RenderThreadManager::HasFrameOnUI() const {
   base::AutoLock lock(lock_);
   return hardware_renderer_has_frame_ || child_frame_.get();
 }
 
-void SharedRendererState::InitializeHardwareDrawIfNeededOnUI() {
+void RenderThreadManager::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);
+RenderThreadManager::InsideHardwareReleaseReset::InsideHardwareReleaseReset(
+    RenderThreadManager* render_thread_manager)
+    : render_thread_manager_(render_thread_manager) {
+  DCHECK(!render_thread_manager_->IsInsideHardwareRelease());
+  render_thread_manager_->SetInsideHardwareRelease(true);
 }
 
-SharedRendererState::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
-  shared_renderer_state_->SetInsideHardwareRelease(false);
+RenderThreadManager::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
+  render_thread_manager_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview