aw: Fallback delegated composite

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"
 #include "base/command_line.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
-#include "cc/output/compositor_frame.h"

[hush (inactive), 2014/10/15 18:17:30]

why is this removed? we still use cc::compositorFrame right?

[boliu, 2014/10/15 19:37:51]

Added back.

 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using content::SynchronousCompositorMemoryPolicy;
@@ skipping 192 matching lines @@
   if (!hardware_enabled_) {
     hardware_enabled_ = compositor_->InitializeHwDraw();
     if (hardware_enabled_) {
       tile_manager_key_ = GlobalTileManager::GetInstance()->PushBack(this);
     }
   }
   if (!hardware_enabled_)
     return false;
 
   ReturnResourceFromParent();
-  SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
-  RequestMemoryPolicy(new_policy);
-  compositor_->SetMemoryPolicy(memory_policy_);
-
   if (shared_renderer_state_->HasCompositorFrame()) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_PreviousFrameUnconsumed",
                          TRACE_EVENT_SCOPE_THREAD);
     SkippedCompositeInDraw();
     return client_->RequestDrawGL(java_canvas, false);
   }
 
+  scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
+  if (!frame.get())
+    return false;
+
+  shared_renderer_state_->SetCompositorFrame(frame.Pass(), false);
+  return client_->RequestDrawGL(java_canvas, false);
+}
+
+scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
+  SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
+  RequestMemoryPolicy(new_policy);
+  compositor_->SetMemoryPolicy(memory_policy_);
+
   parent_draw_constraints_ = shared_renderer_state_->ParentDrawConstraints();
   gfx::Size surface_size(width_, height_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
   gfx::Transform transform_for_tile_priority =
       parent_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;
   if (parent_draw_constraints_.is_layer)
     viewport_rect_for_tile_priority = parent_draw_constraints_.surface_rect;
   else
     viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
 
   scoped_ptr<cc::CompositorFrame> frame =
       compositor_->DemandDrawHw(surface_size,
                                 gfx::Transform(),
                                 viewport,
                                 clip,
                                 viewport_rect_for_tile_priority,
                                 transform_for_tile_priority);
   if (!frame.get())
-    return false;
+    return frame.Pass();
 
   GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
 
-  shared_renderer_state_->SetCompositorFrame(frame.Pass());
   DidComposite();
-  return client_->RequestDrawGL(java_canvas, false);
+  return frame.Pass();
 }
 
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
   // Post an invalidate if the parent draw constraints are stale and there is
   // no pending invalidate.
   if (shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL() ||
       !parent_draw_constraints_.Equals(
         shared_renderer_state_->ParentDrawConstraints())) {
     shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
     EnsureContinuousInvalidation(true, false);
@@ skipping 421 matching lines @@
   TRACE_EVENT1("android_webview",
                "BrowserViewRenderer::FallbackTickFired",
                "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_) {
-    ForceFakeCompositeSW();
+    if (hardware_enabled_) {
+      ReturnResourceFromParent();
+      ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());

[hush (inactive), 2014/10/15 18:17:30]

there is also a frame in HardwareRenderer.commited_frame_ that could contain
some resources. I think you need to return unused resources too, if you are not
going to SetFrameData twice in HardwareRenderer::DrawGL

[boliu, 2014/10/15 19:37:51]

I am calling SetFrameData twice in HWR::DrawGL :)

+      scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
+      if (frame.get()) {
+        shared_renderer_state_->SetCompositorFrame(frame.Pass(), true);
+      }
+    } else {
+      ForceFakeCompositeSW();
+    }
   } else {
     // Pretend we just composited to unblock further invalidates.
     DidComposite();
   }
 }
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
@@ skipping 44 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