Move SharedRendererState ownership to AwContents

android_webview/browser/browser_view_renderer.cc

Index: android_webview/browser/browser_view_renderer.cc
diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index cf6b4b4f6fc9262776adad9e860cc7dbf020bb83..03c8d7906c17a10e75b293c77c70a2728cb531ee 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -88,7 +88,7 @@ BrowserViewRenderer::BrowserViewRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
     bool disable_page_visibility)
     : client_(client),
-      shared_renderer_state_(ui_task_runner, this),
+      shared_renderer_state_(nullptr),
       ui_task_runner_(ui_task_runner),
       disable_page_visibility_(disable_page_visibility),
       compositor_(NULL),
@@ -108,6 +108,7 @@ BrowserViewRenderer::BrowserViewRenderer(
 
 BrowserViewRenderer::~BrowserViewRenderer() {
   DCHECK(compositor_map_.empty());
+  SetSharedRendererState(nullptr);
 }
 
 void BrowserViewRenderer::RegisterWithWebContents(
@@ -116,8 +117,21 @@ void BrowserViewRenderer::RegisterWithWebContents(
                             new BrowserViewRendererUserData(this));
 }
 
+void BrowserViewRenderer::SetSharedRendererState(
+    SharedRendererState* shared_renderer_state) {
+  if (shared_renderer_state_ == shared_renderer_state) return;
+
+  if (shared_renderer_state_) {
+    shared_renderer_state_->SetBrowserViewRendererOnUI(nullptr);
+  }
+  shared_renderer_state_ = shared_renderer_state;
+  if (shared_renderer_state_) {
+    shared_renderer_state_->SetBrowserViewRendererOnUI(this);
+  }
+}
+
 SharedRendererState* BrowserViewRenderer::GetAwDrawGLViewContext() {
-  return &shared_renderer_state_;
+  return shared_renderer_state_;
 }
 
 bool BrowserViewRenderer::RequestDrawGL(bool wait_for_completion) {
@@ -150,16 +164,6 @@ void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
 
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
 
-  // If offscreen pre-raster is disabled, drop everything in hardware. Otherwise
-  // keep the tiles and just delete the HardwareRenderer.
-  if (level >= TRIM_MEMORY_MODERATE) {
-    if (offscreen_pre_raster_)
-      shared_renderer_state_.DeleteHardwareRendererOnUI();
-    else
-      shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
-    return;
-  }
-
   // Just set the memory limit to 0 and drop all tiles. This will be reset to
   // normal levels in the next DrawGL call.
   // TODO(hush): need to setMemoryPolicy to 0 for non-current compositors too.
@@ -169,7 +173,19 @@ void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
     compositor_->SetMemoryPolicy(0u);
 }
 
-void BrowserViewRenderer::UpdateMemoryPolicy() {
+gfx::Rect BrowserViewRenderer::GetInterestRect(bool is_layer) const {
+  if (is_layer || offscreen_pre_raster_) {
+    return gfx::Rect(size_);
+  } else {
+    return last_on_draw_global_visible_rect_;
+  }
+}
+
+void BrowserViewRenderer::UpdateMemoryPolicy(gfx::Rect interest_rect) {
+  if (!compositor_) {
+    return;
+  }
+
   if (!hardware_enabled_) {
     compositor_->SetMemoryPolicy(0u);
     return;
@@ -179,12 +195,6 @@ void BrowserViewRenderer::UpdateMemoryPolicy() {
   if (g_memory_override_in_bytes) {
     bytes_limit = static_cast<size_t>(g_memory_override_in_bytes);
   } else {
-    ParentCompositorDrawConstraints parent_draw_constraints =
-        shared_renderer_state_.GetParentDrawConstraintsOnUI();
-    gfx::Rect interest_rect =
-        offscreen_pre_raster_ || parent_draw_constraints.is_layer
-            ? gfx::Rect(size_)
-            : last_on_draw_global_visible_rect_;
     size_t width = interest_rect.width();
     size_t height = interest_rect.height();
     bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
@@ -217,23 +227,16 @@ bool BrowserViewRenderer::CanOnDraw() {
   return true;
 }
 
-bool BrowserViewRenderer::OnDrawHardware() {
+scoped_ptr<ChildFrame> BrowserViewRenderer::OnDrawHardware(
+    const ParentCompositorDrawConstraints& parent_draw_constraints) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDrawHardware");
 
-  shared_renderer_state_.InitializeHardwareDrawIfNeededOnUI();
-
   if (!CanOnDraw()) {
-    return false;
+    return nullptr;
   }
 
-  shared_renderer_state_.SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
   hardware_enabled_ = true;
 
-  ReturnResourceFromParent();
-  UpdateMemoryPolicy();
-
-  ParentCompositorDrawConstraints parent_draw_constraints =
-      shared_renderer_state_.GetParentDrawConstraintsOnUI();
   gfx::Size surface_size(size_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
@@ -250,34 +253,28 @@ bool BrowserViewRenderer::OnDrawHardware() {
     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);
+  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);
-    return shared_renderer_state_.HasFrameOnUI();
+    return nullptr;
   }
 
-  scoped_ptr<ChildFrame> child_frame = make_scoped_ptr(new ChildFrame(
+  return make_scoped_ptr(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_,
       parent_draw_constraints.is_layer));
-
-  ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
-  shared_renderer_state_.SetCompositorFrameOnUI(std::move(child_frame));
-  return true;
 }
 
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
+  DCHECK(shared_renderer_state_);
   PostInvalidate();
   ParentCompositorDrawConstraints parent_draw_constraints =
-      shared_renderer_state_.GetParentDrawConstraintsOnUI();
+      shared_renderer_state_->GetParentDrawConstraintsOnUI();
   client_->ParentDrawConstraintsUpdated(parent_draw_constraints);
 }
 
@@ -286,30 +283,22 @@ void BrowserViewRenderer::ReturnUnusedResource(
   if (!child_frame.get() || !child_frame->frame.get())
     return;
 
-  cc::CompositorFrameAck frame_ack;
+  cc::ReturnedResourceArray returned_resources;
   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() {
-  SharedRendererState::ReturnedResourcesMap returned_resource_map;
-  shared_renderer_state_.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);
-    }
+      &returned_resources);
+  ReturnResourceFromParent(child_frame->compositor_id,
+                           child_frame->output_surface_id, &returned_resources);
+}
+
+void BrowserViewRenderer::ReturnResourceFromParent(
+    uint32_t compositor_id, uint32_t output_surface_id,
+    cc::ReturnedResourceArray* resources) {
+  content::SynchronousCompositor* compositor = compositor_map_[compositor_id];
+  cc::CompositorFrameAck frame_ack;
+  frame_ack.resources.swap(*resources);
+  if (compositor && !frame_ack.resources.empty()) {
+    compositor->ReturnResources(output_surface_id, frame_ack);
   }
 }
 
@@ -364,9 +353,6 @@ void BrowserViewRenderer::ClearView() {
 }
 
 void BrowserViewRenderer::SetOffscreenPreRaster(bool enable) {
-  if (offscreen_pre_raster_ != enable && compositor_)
-    UpdateMemoryPolicy();
-
   offscreen_pre_raster_ = enable;

[boliu, 2016/03/23 20:42:32]

It's ok to use the constraints from last draw here, instead of doing the whole
dance with AwContents.

 }
 
@@ -424,9 +410,12 @@ void BrowserViewRenderer::OnAttachedToWindow(int width, int height) {
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
-  shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
+  if (compositor_) {
+    compositor_->SetMemoryPolicy(0u);
+  }
+
+  hardware_enabled_ = false;
   attached_to_window_ = false;
-  DCHECK(!hardware_enabled_);
   UpdateCompositorIsActive();
 }
 
@@ -437,19 +426,6 @@ void BrowserViewRenderer::OnComputeScroll(base::TimeTicks animation_time) {
   compositor_->OnComputeScroll(animation_time);
 }
 
-void BrowserViewRenderer::ReleaseHardware() {
-  DCHECK(hardware_enabled_);
-  ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
-  ReturnResourceFromParent();
-  DCHECK(shared_renderer_state_.ReturnedResourcesEmptyOnUI());
-
-  if (compositor_) {
-    compositor_->SetMemoryPolicy(0u);
-  }
-
-  hardware_enabled_ = false;
-}
-
 bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
@@ -698,7 +674,6 @@ void BrowserViewRenderer::PostInvalidate() {
 
 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(compositor_);
-  ReturnResourceFromParent();
   return compositor_->DemandDrawSw(canvas);
 }