Transfer DrawGLFunctor ownership from AwContents to AwGLFunctor

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/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/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 {
+class RequestInvokeGLTracker {
  public:
-  RequestDrawGLTracker();
+  RequestInvokeGLTracker();
   bool ShouldRequestOnNonUiThread(RenderThreadManager* state);
   bool ShouldRequestOnUiThread(RenderThreadManager* state);
   void ResetPending();
   void SetQueuedFunctorOnUi(RenderThreadManager* state);
 
  private:
   base::Lock lock_;
   RenderThreadManager* pending_ui_;
   RenderThreadManager* pending_non_ui_;
 };
 
-RequestDrawGLTracker::RequestDrawGLTracker()
-    : pending_ui_(NULL), pending_non_ui_(NULL) {
-}
+RequestInvokeGLTracker::RequestInvokeGLTracker()
+    : pending_ui_(NULL), pending_non_ui_(NULL) {}
 
-bool RequestDrawGLTracker::ShouldRequestOnNonUiThread(
+bool RequestInvokeGLTracker::ShouldRequestOnNonUiThread(
     RenderThreadManager* state) {
   base::AutoLock lock(lock_);
   if (pending_ui_ || pending_non_ui_)
     return false;
   pending_non_ui_ = state;
   return true;
 }
 
-bool RequestDrawGLTracker::ShouldRequestOnUiThread(RenderThreadManager* state) {
+bool RequestInvokeGLTracker::ShouldRequestOnUiThread(
+    RenderThreadManager* state) {
   base::AutoLock lock(lock_);
   if (pending_non_ui_) {
-    pending_non_ui_->ResetRequestDrawGLCallback();
+    pending_non_ui_->ResetRequestInvokeGLCallback();
     pending_non_ui_ = NULL;
   }
-  // At this time, we could have already called RequestDrawGL on the UI thread,
+  // At this time, we could have already called RequestInvokeGL 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.
+  // don't schedule another requestInvokeGL on the UI thread.
   if (pending_ui_)
     return false;
   pending_ui_ = state;
   return true;
 }
 
-void RequestDrawGLTracker::ResetPending() {
+void RequestInvokeGLTracker::ResetPending() {
   base::AutoLock lock(lock_);
   pending_non_ui_ = NULL;
   pending_ui_ = NULL;
 }
 
-void RequestDrawGLTracker::SetQueuedFunctorOnUi(RenderThreadManager* state) {
+void RequestInvokeGLTracker::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;
-
+base::LazyInstance<internal::RequestInvokeGLTracker>
+    g_request_invoke_gl_tracker = LAZY_INSTANCE_INITIALIZER;
 }
 
 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();
+  ResetRequestInvokeGLCallback();
 }
 
 RenderThreadManager::~RenderThreadManager() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!hardware_renderer_.get());
 }
 
-void RenderThreadManager::ClientRequestDrawGL(bool for_idle) {
+void RenderThreadManager::ClientRequestInvokeGL(bool for_idle) {
   if (ui_loop_->BelongsToCurrentThread()) {
-    if (!g_request_draw_gl_tracker.Get().ShouldRequestOnUiThread(this))
+    if (!g_request_invoke_gl_tracker.Get().ShouldRequestOnUiThread(this))
       return;
-    ClientRequestDrawGLOnUI();
+    ClientRequestInvokeGLOnUI();
   } else {
-    if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNonUiThread(this))
+    if (!g_request_invoke_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 RenderThreadManager::DidDrawGLProcess() {
-  g_request_draw_gl_tracker.Get().ResetPending();
+void RenderThreadManager::DidInvokeGLProcess() {
+  g_request_invoke_gl_tracker.Get().ResetPending();
 }
 
-void RenderThreadManager::ResetRequestDrawGLCallback() {
+void RenderThreadManager::ResetRequestInvokeGLCallback() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   base::AutoLock lock(lock_);
   request_draw_gl_cancelable_closure_.Reset(base::Bind(
-      &RenderThreadManager::ClientRequestDrawGLOnUI, base::Unretained(this)));
+      &RenderThreadManager::ClientRequestInvokeGLOnUI, base::Unretained(this)));
   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 }
 
-void RenderThreadManager::ClientRequestDrawGLOnUI() {
+void RenderThreadManager::ClientRequestInvokeGLOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
-  ResetRequestDrawGLCallback();
-  g_request_draw_gl_tracker.Get().SetQueuedFunctorOnUi(this);
-  if (!client_->RequestDrawGL(false)) {
-    g_request_draw_gl_tracker.Get().ResetPending();
+  ResetRequestInvokeGLCallback();
+  g_request_invoke_gl_tracker.Get().SetQueuedFunctorOnUi(this);
+  if (!client_->RequestInvokeGL(false)) {
+    g_request_invoke_gl_tracker.Get().ResetPending();
     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
   }
 }
 
 void RenderThreadManager::UpdateParentDrawConstraintsOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   client_->OnParentDrawConstraintsUpdated();
 }
 
 void RenderThreadManager::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
@@ skipping 96 matching lines @@
     return;
   }
 
   // kModeProcessNoContext should never happen because we tear down hardware
   // in onTrimMemory. However that guarantee is maintained outside of chromium
   // code. Not notifying shared state in kModeProcessNoContext can lead to
   // immediate deadlock, which is slightly more catastrophic than leaks or
   // corruption.
   if (draw_info->mode == AwDrawGLInfo::kModeProcess ||
       draw_info->mode == AwDrawGLInfo::kModeProcessNoContext) {
-    DidDrawGLProcess();
+    DidInvokeGLProcess();
   }
 
   {
     GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
     base::AutoLock lock(lock_);
     if (renderer_manager_key_ != manager->NullKey()) {
       manager->DidDrawGL(renderer_manager_key_);
     }
   }
 
@@ skipping 41 matching lines @@
 }
 
 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.
+  // onTrimMemory will result in an unnecessary Render Thread InvokeGL call.
   bool hardware_initialized = HasFrameOnUI();
   if (hardware_initialized) {
-    bool draw_functor_succeeded = client_->RequestDrawGL(true);
+    bool draw_functor_succeeded = client_->RequestInvokeGL(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);
     }
   }
 
   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.
-    client_->RequestDrawGL(true);
+    client_->RequestInvokeGL(true);
   }
 }
 
 bool RenderThreadManager::HasFrameOnUI() const {
   base::AutoLock lock(lock_);
   return hardware_renderer_has_frame_ || child_frame_.get();
 }
 
 bool RenderThreadManager::HasFrameForHardwareRendererOnRT() const {
   base::AutoLock lock(lock_);
@@ skipping 15 matching lines @@
     : render_thread_manager_(render_thread_manager) {
   DCHECK(!render_thread_manager_->IsInsideHardwareRelease());
   render_thread_manager_->SetInsideHardwareRelease(true);
 }
 
 RenderThreadManager::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
   render_thread_manager_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview