Part 2: WIP Refactor Webview graphics related code

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 "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/common/aw_switches.h"
 #include "base/auto_reset.h"
@@ skipping 288 matching lines @@
   bool needs_force_invalidate =
       shared_renderer_state_.NeedsForceInvalidateOnNextDrawGLOnUI();
   if (needs_force_invalidate ||
       !parent_draw_constraints_.Equals(
           shared_renderer_state_.GetParentDrawConstraintsOnUI())) {
     shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(false);
     EnsureContinuousInvalidation(true, needs_force_invalidate);
   }
 }
 
-void BrowserViewRenderer::ReturnUnusedResource(
-    scoped_ptr<cc::CompositorFrame> frame) {
-  if (!frame.get())
-    return;
-
-  cc::CompositorFrameAck frame_ack;
-  cc::TransferableResource::ReturnResources(
-      frame->delegated_frame_data->resource_list, &frame_ack.resources);
-  if (compositor_ && !frame_ack.resources.empty())
-    compositor_->ReturnResources(frame_ack);
-}
-
 void BrowserViewRenderer::ReturnResourceFromParent() {
   cc::CompositorFrameAck frame_ack;
   shared_renderer_state_.SwapReturnedResourcesOnUI(&frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty()) {
     compositor_->ReturnResources(frame_ack);
   }
 }
 
 void BrowserViewRenderer::DidSkipCommitFrame() {
   // Treat it the same way as skipping onDraw.
@@ skipping 115 matching lines @@
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   attached_to_window_ = false;
   DCHECK(!hardware_enabled_);
 }
 
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
-  // TODO(hush): do this in somewhere else. Either in hardware render or in
-  // shared renderer state.
-  ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());
   ReturnResourceFromParent();
-  DCHECK(shared_renderer_state_.ReturnedResourcesEmpty());
+  DCHECK(shared_renderer_state_.ReturnedResourcesEmptyOnUI());
 
   if (compositor_) {
     compositor_->ReleaseHwDraw();
     SynchronousCompositorMemoryPolicy zero_policy;
     RequestMemoryPolicy(zero_policy);
   }
 
   hardware_enabled_ = false;
   GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
 }
 
+void BrowserViewRenderer::InvalidateOnFunctorDestroy() {
+  client_->InvalidateOnFunctorDestroy();
+}
+
 bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
 }
 
 gfx::Rect BrowserViewRenderer::GetScreenRect() const {
   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
 }
 
 void BrowserViewRenderer::DidInitializeCompositor(
@@ skipping 265 matching lines @@
                "compositor_needs_continuous_invalidate_",
                compositor_needs_continuous_invalidate_);
 
   // This should only be called if OnDraw or DrawGL did not come in time, which
   // means block_invalidates_ must still be true.
   DCHECK(block_invalidates_);
   fallback_tick_pending_ = false;
   if (compositor_needs_continuous_invalidate_ && compositor_) {
     if (hardware_enabled_) {
       ReturnResourceFromParent();
-      ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());

[boliu, 2014/10/28 19:49:43]

This isn't quite the same anymore.

This used to return the resource to child compositor. Now it's just hanging
around in SRS::returned_resources_

I think if we need PassCompositorFrame on both threads, we should just have two
versions of it for now. The one on UI can be called PassUncommittedFrameOnUI()
or something like that to distinguish them.

In the future, we can refactor CommitFrame to be on SRS, which pushes the frame
into HR.

[hush (inactive), 2014/10/29 19:57:04]

The resources in SRS::returned_resources_ will be returned the next time
ReturnResourceFromParent() is called, I think. So it is not a correctness
problem?
Anyways I just added PassUncommittedFrameOnUI() as suggested, which has the same
implementation of PassCompositorFrame(). So it is kind of weird.

       scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
       if (frame.get()) {
+        // Unused resource will be returned in SetCompositorFrameOnUI.
         shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), true);
       }
     } else {
       ForceFakeCompositeSW();
     }
   } else {
     // Pretend we just composited to unblock further invalidates.
     DidComposite();
   }
 }
@@ skipping 49 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