Refactor BrowserViewRenderer-RenderThreadManager relationship.

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/compositor_frame_producer.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"
@@ skipping 64 matching lines @@
 
 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),
+      compositor_frame_producer_(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(client_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
   ResetRequestInvokeGLCallback();
 }
 
 RenderThreadManager::~RenderThreadManager() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   DCHECK(!hardware_renderer_.get());
+  if (compositor_frame_producer_) {
+    compositor_frame_producer_->OnCompositorFrameConsumerWillDestroy();
+  }
 }
 
 void RenderThreadManager::ClientRequestInvokeGL(bool for_idle) {
   if (ui_loop_->BelongsToCurrentThread()) {
     if (!g_request_invoke_gl_tracker.Get().ShouldRequestOnUiThread(this))
       return;
     ClientRequestInvokeGLOnUI();
   } else {
     if (!g_request_invoke_gl_tracker.Get().ShouldRequestOnNonUiThread(this))
       return;
@@ skipping 28 matching lines @@
   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();
+  if (compositor_frame_producer_) {
+    compositor_frame_producer_->OnParentDrawConstraintsUpdated();
+  }
 }
 
 void RenderThreadManager::SetScrollOffsetOnUI(gfx::Vector2d scroll_offset) {
   base::AutoLock lock(lock_);
   scroll_offset_ = scroll_offset;
 }
 
 gfx::Vector2d RenderThreadManager::GetScrollOffsetOnRT() {
   base::AutoLock lock(lock_);
   return scroll_offset_;
@@ skipping 180 matching lines @@
       renderer_manager_key_ = manager->NullKey();
     }
   }
 
   if (hardware_initialized) {
     // Flush any invoke functors that's caused by ReleaseHardware.
     client_->RequestInvokeGL(true);
   }
 }
 
+void RenderThreadManager::SetCompositorFrameProducer(
+    CompositorFrameProducer* compositor_frame_producer) {
+  compositor_frame_producer_ = compositor_frame_producer;
+}
+
 bool RenderThreadManager::HasFrameOnUI() const {
   base::AutoLock lock(lock_);
   return hardware_renderer_has_frame_ || child_frame_.get();
 }
 
 bool RenderThreadManager::HasFrameForHardwareRendererOnRT() const {
   base::AutoLock lock(lock_);
   return !!child_frame_;
 }
 
@@ skipping 12 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