Refactor BrowserViewRenderer-RenderThreadManager relationship.

android_webview/browser/browser_view_renderer.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/browser_view_renderer.h"
 
 #include <utility>
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/child_frame.h"
+#include "android_webview/browser/compositor_frame_consumer.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 64 matching lines @@
     content::WebContents* web_contents) {
   return BrowserViewRendererUserData::GetBrowserViewRenderer(web_contents);
 }
 
 BrowserViewRenderer::BrowserViewRenderer(
     BrowserViewRendererClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
     bool disable_page_visibility)
     : client_(client),
       ui_task_runner_(ui_task_runner),
-      render_thread_manager_(nullptr),
+      compositor_frame_consumer_(nullptr),
       disable_page_visibility_(disable_page_visibility),
       compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       hardware_enabled_(false),
       dip_scale_(0.f),
       page_scale_factor_(1.f),
       min_page_scale_factor_(0.f),
       max_page_scale_factor_(0.f),
       on_new_picture_enable_(false),
       clear_view_(false),
       offscreen_pre_raster_(false),
       next_compositor_id_(1) {}
 
 BrowserViewRenderer::~BrowserViewRenderer() {
   DCHECK(compositor_map_.empty());
+  SetCompositorFrameConsumer(nullptr);
 }
 
-void BrowserViewRenderer::SetRenderThreadManager(
-    RenderThreadManager* render_thread_manager) {
-  render_thread_manager_ = render_thread_manager;
+void BrowserViewRenderer::SetCompositorFrameConsumer(
+    CompositorFrameConsumer* compositor_frame_consumer) {
+  if (compositor_frame_consumer == compositor_frame_consumer_) {
+    return;
+  }
+  if (compositor_frame_consumer_) {
+    compositor_frame_consumer_->SetCompositorFrameProducer(nullptr);
+  }
+  compositor_frame_consumer_ = compositor_frame_consumer;
+  if (compositor_frame_consumer_) {
+    compositor_frame_consumer_->SetCompositorFrameProducer(this);
+  }
 }
 
 void BrowserViewRenderer::RegisterWithWebContents(
     content::WebContents* web_contents) {
   web_contents->SetUserData(kBrowserViewRendererUserDataKey,
                             new BrowserViewRendererUserData(this));
 }
 
 void BrowserViewRenderer::TrimMemory() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
@@ skipping 51 matching lines @@
   if (clear_view_) {
     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_ClearView",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   return true;
 }
 
 bool BrowserViewRenderer::OnDrawHardware() {
-  DCHECK(render_thread_manager_);
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDrawHardware");
+  if (!compositor_frame_consumer_) {
+    return false;
+  }
 
-  render_thread_manager_->InitializeHardwareDrawIfNeededOnUI();
+  compositor_frame_consumer_->InitializeHardwareDrawIfNeededOnUI();
 
   if (!CanOnDraw()) {
     return false;
   }
 
-  render_thread_manager_->SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
+  compositor_frame_consumer_->SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
   hardware_enabled_ = true;
 
   external_draw_constraints_ =
-      render_thread_manager_->GetParentDrawConstraintsOnUI();
+      compositor_frame_consumer_->GetParentDrawConstraintsOnUI();
 
-  ReturnResourceFromParent();
+  ReturnResourceFromParent(compositor_frame_consumer_);
   UpdateMemoryPolicy();
 
   gfx::Size surface_size(size_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
   gfx::Transform transform_for_tile_priority =
       external_draw_constraints_.transform;
 
   // If the WebView is on a layer, WebView does not know what transform is
   // applied onto the layer so global visible rect does not make sense here.
   // In this case, just use the surface rect for tiling.
   gfx::Rect viewport_rect_for_tile_priority;
 
   // Leave viewport_rect_for_tile_priority empty if offscreen_pre_raster_ is on.
   if (!offscreen_pre_raster_ && !external_draw_constraints_.is_layer) {
     viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
   }
 
   content::SynchronousCompositor::Frame frame =
       compositor_->DemandDrawHw(surface_size,
                                 gfx::Transform(),
                                 viewport,
                                 clip,
                                 viewport_rect_for_tile_priority,
                                 transform_for_tile_priority);
   if (!frame.frame.get()) {
     TRACE_EVENT_INSTANT0("android_webview", "NoNewFrame",
                          TRACE_EVENT_SCOPE_THREAD);
-    hardware_enabled_ = render_thread_manager_->HasFrameOnUI();
+    hardware_enabled_ = compositor_frame_consumer_->HasFrameOnUI();
     if (!hardware_enabled_)
       UpdateMemoryPolicy();
     return hardware_enabled_;
   }
 
   std::unique_ptr<ChildFrame> child_frame = base::WrapUnique(new ChildFrame(
       frame.output_surface_id, std::move(frame.frame),
       GetCompositorID(compositor_), viewport_rect_for_tile_priority.IsEmpty(),
       transform_for_tile_priority, offscreen_pre_raster_,
       external_draw_constraints_.is_layer));
 
-  ReturnUnusedResource(render_thread_manager_->PassUncommittedFrameOnUI());
-  render_thread_manager_->SetFrameOnUI(std::move(child_frame));
+  ReturnUnusedResource(compositor_frame_consumer_->PassUncommittedFrameOnUI());
+  compositor_frame_consumer_->SetFrameOnUI(std::move(child_frame));
   return true;
 }
 
 void BrowserViewRenderer::OnParentDrawConstraintsUpdated() {
-  DCHECK(render_thread_manager_);
+  DCHECK(compositor_frame_consumer_);
   PostInvalidate();
   external_draw_constraints_ =
-      render_thread_manager_->GetParentDrawConstraintsOnUI();
+      compositor_frame_consumer_->GetParentDrawConstraintsOnUI();
   UpdateMemoryPolicy();
 }
 
+void BrowserViewRenderer::OnCompositorFrameConsumerWillDestroy() {
+  DCHECK(compositor_frame_consumer_);
+  SetCompositorFrameConsumer(nullptr);
+}
+
 void BrowserViewRenderer::ReturnUnusedResource(
     std::unique_ptr<ChildFrame> child_frame) {
   if (!child_frame.get() || !child_frame->frame.get())
     return;
 
   cc::CompositorFrameAck frame_ack;
   cc::TransferableResource::ReturnResources(
       child_frame->frame->delegated_frame_data->resource_list,
       &frame_ack.resources);
   content::SynchronousCompositor* compositor =
       compositor_map_[child_frame->compositor_id];
   if (compositor && !frame_ack.resources.empty())
     compositor->ReturnResources(child_frame->output_surface_id, frame_ack);
 }
 
-void BrowserViewRenderer::ReturnResourceFromParent() {
-  DCHECK(render_thread_manager_);
-  RenderThreadManager::ReturnedResourcesMap returned_resource_map;
-  render_thread_manager_->SwapReturnedResourcesOnUI(&returned_resource_map);
+void BrowserViewRenderer::ReturnResourceFromParent(
+    CompositorFrameConsumer* compositor_frame_consumer) {
+  CompositorFrameConsumer::ReturnedResourcesMap returned_resource_map;
+  compositor_frame_consumer->SwapReturnedResourcesOnUI(&returned_resource_map);
   for (auto iterator = returned_resource_map.begin();
        iterator != returned_resource_map.end(); iterator++) {
     uint32_t compositor_id = iterator->first;
     content::SynchronousCompositor* compositor = compositor_map_[compositor_id];
     cc::CompositorFrameAck frame_ack;
     frame_ack.resources.swap(iterator->second.resources);
 
     if (compositor && !frame_ack.resources.empty()) {
       compositor->ReturnResources(iterator->second.output_surface_id,
                                   frame_ack);
@@ skipping 125 matching lines @@
 }
 
 void BrowserViewRenderer::OnComputeScroll(base::TimeTicks animation_time) {
   if (!compositor_)
     return;
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnComputeScroll");
   compositor_->OnComputeScroll(animation_time);
 }
 
 void BrowserViewRenderer::ReleaseHardware() {
-  ReturnUnusedResource(render_thread_manager_->PassUncommittedFrameOnUI());
-  ReturnResourceFromParent();
-  DCHECK(render_thread_manager_->ReturnedResourcesEmptyOnUI());
+  if (compositor_frame_consumer_) {
+    ReturnUnusedResource(
+        compositor_frame_consumer_->PassUncommittedFrameOnUI());
+    ReturnResourceFromParent(compositor_frame_consumer_);
+    DCHECK(compositor_frame_consumer_->ReturnedResourcesEmptyOnUI());

[boliu, 2016/04/21 18:01:32]

This at the moment still assumes RTM outlives BVR still I think, because
consumer actually have no way to return resources, say if RTM wants to die first
before BVR.

This is fine now, but just something to be aware of later when the assumption is
no longer true.

Another way we talked in the earlier CL to solve this is in
SetCompositorFrameConsumer, make sure all resources are returned from the
consumer that's no longer active. That might be safer thing to do for now. Then
you can write a unit test that RTM is destroyed first, and verify all resources
are still returned.

+  }
   hardware_enabled_ = false;
   UpdateMemoryPolicy();
 }
 
 bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
 }
 
 bool BrowserViewRenderer::IsClientVisible() const {
@@ skipping 266 matching lines @@
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
                       overscroll_rounding_error_.ToString().c_str());
   base::StringAppendF(
       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
   return str;
 }
 
 }  // namespace android_webview