cc: Make scheduling be driven by vsync for android webview.

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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
       compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       hardware_enabled_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
-      compositor_needs_continuous_invalidate_(false),
       invalidate_after_composite_(false),
       block_invalidates_(false),
       fallback_tick_pending_(false) {
 }
 
 BrowserViewRenderer::~BrowserViewRenderer() {
 }
 
 SharedRendererState* BrowserViewRenderer::GetAwDrawGLViewContext() {
   return &shared_renderer_state_;
@@ skipping 152 matching lines @@
                                 gfx::Transform(),
                                 viewport,
                                 clip,
                                 viewport_rect_for_tile_priority,
                                 transform_for_tile_priority);
   if (frame.get())
     DidComposite();
   return frame.Pass();
 }
 
+void BrowserViewRenderer::ForceCompositeHw() {
+  ReturnResourceFromParent();
+  ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
+  scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
+  if (frame.get()) {
+    shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), true);
+  }
+}
+
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
   // Post an invalidate if the parent draw constraints are stale and there is
   // no pending invalidate.
   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);
+    PostInvalidateWithFallback(needs_force_invalidate);
   }
 }
 
 void BrowserViewRenderer::ReturnUnusedResource(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (!frame.get())
     return;
 
   cc::CompositorFrameAck frame_ack;
   cc::TransferableResource::ReturnResources(
@@ skipping 52 matching lines @@
 
 void BrowserViewRenderer::ClearView() {
   TRACE_EVENT_INSTANT0("android_webview",
                        "BrowserViewRenderer::ClearView",
                        TRACE_EVENT_SCOPE_THREAD);
   if (clear_view_)
     return;
 
   clear_view_ = true;
   // Always invalidate ignoring the compositor to actually clear the webview.
-  EnsureContinuousInvalidation(true, false);
+  PostInvalidateWithFallback(false);
 }
 
 void BrowserViewRenderer::SetIsPaused(bool paused) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "BrowserViewRenderer::SetIsPaused",
                        TRACE_EVENT_SCOPE_THREAD,
                        "paused",
                        paused);
   is_paused_ = paused;
-  EnsureContinuousInvalidation(false, false);
+  UpdateCompositorIsActive();

[boliu, 2015/02/11 02:28:15]

Hmm, for now when fallback tick is still not removed, it's still important to
check the state of fallback ticks, since fallback tick might go from throttled
to non-throttled. In that case, if compositor is waiting for an invalidate, then
we need to schedule a fallback tick.

 }
 
 void BrowserViewRenderer::SetViewVisibility(bool view_visible) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "BrowserViewRenderer::SetViewVisibility",
                        TRACE_EVENT_SCOPE_THREAD,
                        "view_visible",
                        view_visible);
   view_visible_ = view_visible;
 }
 
 void BrowserViewRenderer::SetWindowVisibility(bool window_visible) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "BrowserViewRenderer::SetWindowVisibility",
                        TRACE_EVENT_SCOPE_THREAD,
                        "window_visible",
                        window_visible);
   window_visible_ = window_visible;
-  EnsureContinuousInvalidation(false, false);
+  UpdateCompositorIsActive();
 }
 
 void BrowserViewRenderer::OnSizeChanged(int width, int height) {
   TRACE_EVENT_INSTANT2("android_webview",
                        "BrowserViewRenderer::OnSizeChanged",
                        TRACE_EVENT_SCOPE_THREAD,
                        "width",
                        width,
                        "height",
                        height);
   size_.SetSize(width, height);
 }
 
 void BrowserViewRenderer::OnAttachedToWindow(int width, int height) {
   TRACE_EVENT2("android_webview",
                "BrowserViewRenderer::OnAttachedToWindow",
                "width",
                width,
                "height",
                height);
   attached_to_window_ = true;
   size_.SetSize(width, height);
+  UpdateCompositorIsActive();
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
   attached_to_window_ = false;
   DCHECK(!hardware_enabled_);
+  UpdateCompositorIsActive();
 }
 
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
   ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
   ReturnResourceFromParent();
   DCHECK(shared_renderer_state_.ReturnedResourcesEmptyOnUI());
 
   if (compositor_) {
     compositor_->ReleaseHwDraw();
@@ skipping 11 matching lines @@
   return gfx::Rect(client_->GetLocationOnScreen(), size_);
 }
 
 void BrowserViewRenderer::DidInitializeCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview",
                "BrowserViewRenderer::DidInitializeCompositor");
   DCHECK(compositor);
   DCHECK(!compositor_);
   compositor_ = compositor;
+  UpdateCompositorIsActive();
 }
 
 void BrowserViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
   DCHECK(compositor_);
   compositor_ = NULL;
 }
 
-void BrowserViewRenderer::SetContinuousInvalidate(bool invalidate) {
-  if (compositor_needs_continuous_invalidate_ == invalidate)
-    return;
-
-  TRACE_EVENT_INSTANT1("android_webview",
-                       "BrowserViewRenderer::SetContinuousInvalidate",
-                       TRACE_EVENT_SCOPE_THREAD,
-                       "invalidate",
-                       invalidate);
-  compositor_needs_continuous_invalidate_ = invalidate;
-
-  EnsureContinuousInvalidation(false, false);
-}
-
 void BrowserViewRenderer::SetDipScale(float dip_scale) {
   dip_scale_ = dip_scale;
   CHECK_GT(dip_scale_, 0.f);
 }
 
 gfx::Vector2d BrowserViewRenderer::max_scroll_offset() const {
   DCHECK_GT(dip_scale_, 0.f);
   return gfx::ToCeiledVector2d(gfx::ScaleVector2d(
       max_scroll_offset_dip_, dip_scale_ * page_scale_factor_));
 }
@@ skipping 147 matching lines @@
     overscroll_rounding_error_ = gfx::Vector2dF();
   gfx::Vector2dF scaled_overscroll_delta =
       gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale);
   gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d(
       scaled_overscroll_delta + overscroll_rounding_error_);
   overscroll_rounding_error_ =
       scaled_overscroll_delta - rounded_overscroll_delta;
   client_->DidOverscroll(rounded_overscroll_delta);
 }
 
-void BrowserViewRenderer::EnsureContinuousInvalidation(
-    bool force_invalidate,
+void BrowserViewRenderer::PostInvalidate() {
+  TRACE_EVENT_INSTANT0("android_webview", "BrowserViewRenderer::PostInvalidate",
+                       TRACE_EVENT_SCOPE_THREAD);
+  PostInvalidateWithFallback(false);
+}
+
+void BrowserViewRenderer::PostInvalidateWithFallback(
     bool skip_reschedule_tick) {
-  if (force_invalidate)
+  if (block_invalidates_) {
     invalidate_after_composite_ = true;

[boliu, 2015/02/11 02:28:14]

I think BVR needs a general clean up before having massive changes like this :(

invalidate_after_composite_ and skip_reschedule_tick can be removed period, we
don't need or want that behavior anymore

block_invalidate_ and fallback_tick_pending_ can probably be merged into one
because DidSkipCompositeInDraw should be removed too

I don't know what's easier, me trying to clean this up first and you try a
rebase, just remove these things here and I'll clean the pieces up later..

-
-  // This method should be called again when any of these conditions change.
-  bool need_invalidate =
-      compositor_needs_continuous_invalidate_ || invalidate_after_composite_;
-  if (!need_invalidate || block_invalidates_)
     return;
-
-  if (!compositor_needs_continuous_invalidate_ && invalidate_after_composite_)
-    invalidate_after_composite_ = false;
+  }
 
   // Always call view invalidate. We rely the Android framework to ignore the
   // invalidate when it's not needed such as when view is not visible.
   client_->PostInvalidate();
 
+  // Always clear any queued invalidates when posting a new one.
+  invalidate_after_composite_ = false;
+
   // Stop fallback ticks when one of these is true.
   // 1) Webview is paused. Also need to check we are not in clear view since
   // paused, offscreen still expect clear view to recover.
   // 2) If we are attached to window and the window is not visible (eg when
   // app is in the background). We are sure in this case the webview is used
   // "on-screen" but that updates are not needed when in the background.
   bool throttle_fallback_tick =
       (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);

[boliu, 2015/02/11 02:28:14]

clear_view_ *was* here because we still want activations to happen, because
activations unsets clear_view_. So in theory, we don't care about clear_view_
here (ie draw), but we do care about it in UpdateCompositorIsActive (ie
activation).

But this is all too complicated to reason about. How about use the exact same
(or I guess opposite) condition in both places for now?

+
   if (throttle_fallback_tick)
     return;
 
-  block_invalidates_ = compositor_needs_continuous_invalidate_;
+  // Start blocking any invalidates posted. Eventually DidComposite or
+  // DidSkipCompositeInDraw will be called either via onDraw or the fallback
+  // tick and invalidates will be unblocked.
+  block_invalidates_ = true;
+
   if (skip_reschedule_tick && fallback_tick_pending_)
     return;
 
-  // Unretained here is safe because the callbacks are cancelled when
-  // they are destroyed.
   post_fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::PostFallbackTick,
                                        base::Unretained(this)));
   fallback_tick_fired_.Cancel();
-  fallback_tick_pending_ = false;
 
-  // No need to reschedule fallback tick if compositor does not need to be
-  // ticked. This can happen if this is reached because force_invalidate is
-  // true.
-  if (compositor_needs_continuous_invalidate_) {
-    fallback_tick_pending_ = true;
-    ui_task_runner_->PostTask(FROM_HERE, post_fallback_tick_.callback());
-  }
+  fallback_tick_pending_ = true;
+  ui_task_runner_->PostTask(FROM_HERE, post_fallback_tick_.callback());
 }
 
 void BrowserViewRenderer::PostFallbackTick() {
   DCHECK(fallback_tick_fired_.IsCancelled());
   fallback_tick_fired_.Reset(base::Bind(&BrowserViewRenderer::FallbackTickFired,
                                         base::Unretained(this)));
-  if (compositor_needs_continuous_invalidate_) {
+  if (compositor_) {

[boliu, 2015/02/11 02:28:14]

don't really need this check either

     ui_task_runner_->PostDelayedTask(
         FROM_HERE,
         fallback_tick_fired_.callback(),
         base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
-  } else {
-    // Pretend we just composited to unblock further invalidates.
-    DidComposite();
   }
+  // Pretend we just composited to unblock further invalidates.
+  DidComposite();

[boliu, 2015/02/11 02:28:14]

just remove this, once compositor is gone, it's gone for good

 }
 
 void BrowserViewRenderer::FallbackTickFired() {
-  TRACE_EVENT1("android_webview",
-               "BrowserViewRenderer::FallbackTickFired",
-               "compositor_needs_continuous_invalidate_",
-               compositor_needs_continuous_invalidate_);
-
+  TRACE_EVENT0("android_webview", "BrowserViewRenderer::FallbackTickFired");
   // 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 (compositor_) {
     if (hardware_enabled_) {
-      ReturnResourceFromParent();
-      ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
-      scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
-      if (frame.get()) {
-        shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), true);
-      }
+      ForceCompositeHw();
     } else {
       ForceFakeCompositeSW();
     }
-  } else {
-    // Pretend we just composited to unblock further invalidates.
-    DidComposite();
   }
+  // Pretend we just composited to unblock further invalidates.
+  DidComposite();

[boliu, 2015/02/11 02:28:15]

ditto

 }
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(0);
   SkCanvas canvas(bitmap);
   CompositeSW(&canvas);
 }
 
 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(compositor_);
   ReturnResourceFromParent();
   bool result = compositor_->DemandDrawSw(canvas);
   DidComposite();
   return result;
 }
 
 void BrowserViewRenderer::DidComposite() {
   block_invalidates_ = false;
+
   post_fallback_tick_.Cancel();
   fallback_tick_fired_.Cancel();
   fallback_tick_pending_ = false;
-  EnsureContinuousInvalidation(false, false);
+
+  if (invalidate_after_composite_)
+    PostInvalidateWithFallback(false);
 }
 
 void BrowserViewRenderer::DidSkipCompositeInDraw() {
+  DCHECK(block_invalidates_);
   block_invalidates_ = false;
-  EnsureContinuousInvalidation(true, true);
+  PostInvalidateWithFallback(true);
+}
+
+void BrowserViewRenderer::UpdateCompositorIsActive() {
+  if (compositor_)
+    compositor_->SetIsActive(!is_paused_ &&
+                             (!attached_to_window_ || window_visible_));
 }
 
 std::string BrowserViewRenderer::ToString() const {
   std::string str;
   base::StringAppendF(&str, "is_paused: %d ", is_paused_);
   base::StringAppendF(&str, "view_visible: %d ", view_visible_);
   base::StringAppendF(&str, "window_visible: %d ", window_visible_);
   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
-  base::StringAppendF(&str,
-                      "compositor_needs_continuous_invalidate: %d ",
-                      compositor_needs_continuous_invalidate_);
+  base::StringAppendF(&str, "invalidate_after_composite: %d ",
+                      invalidate_after_composite_);
   base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_);
+  base::StringAppendF(&str, "fallback_tick_pending: %d ",
+                      fallback_tick_pending_);
   base::StringAppendF(&str, "view size: %s ", size_.ToString().c_str());
   base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_);
   base::StringAppendF(&str,
                       "global visible rect: %s ",
                       last_on_draw_global_visible_rect_.ToString().c_str());
   base::StringAppendF(
       &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str());
   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