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

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 760 matching lines @@
     SkColor color) {
   if (cached_background_color_ == color)
     return;
 
   cached_background_color_ = color;
   if (content_view_core_)
     content_view_core_->OnBackgroundColorChanged(color);
 }
 
 void RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames(bool enabled) {
-  DCHECK(using_browser_compositor_);
   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::OnSetNeedsBeginFrames",
                "enabled", enabled);
   if (enabled)
     RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
   else
     outstanding_vsync_requests_ &= ~PERSISTENT_BEGIN_FRAME;
 }
 
 void RenderWidgetHostViewAndroid::OnStartContentIntent(
     const GURL& content_url) {
@@ skipping 687 matching lines @@
 void RenderWidgetHostViewAndroid::HideInternal(
     bool hide_frontbuffer,
     bool stop_observing_root_window) {
   if (hide_frontbuffer) {
     if (layer_.get() && locks_on_frame_count_ == 0)
       layer_->SetHideLayerAndSubtree(true);
 
     frame_evictor_->SetVisible(false);
   }
 
   if (stop_observing_root_window)

[jdduke (slow), 2015/03/30 22:30:42]

Bo pointed out that WebView apps might conceivably be visible *and* animating
after the activity is paused and we call RWHVAndroid::Hide.

One solution for that would be to remove this StopObservingRootWindow() call, as
it's really an optimization. Instead, we'd rely solely on the
OnSetNeedsBeginFrame logic, which for WebView isn't disabled when the web
contents is hidden. However, Bo mentioned that it might be worth breaking such
non-conforming cases explicitly for the sake of power savings, so we can
probably just cross that bridge when we come to it.

     StopObservingRootWindow();
 
   if (!host_ || host_->is_hidden())
     return;
 
   if (overscroll_controller_)
     overscroll_controller_->Disable();
 
   // We don't know if we will ever get a frame if we are hiding the renderer, so
   // we need to cancel all requests
@@ skipping 24 matching lines @@
 
   if (!layer_.get())
     return;
 
   content_view_core_->RemoveLayer(layer_);
   if (overscroll_controller_)
     overscroll_controller_->Disable();
 }
 
 void RenderWidgetHostViewAndroid::RequestVSyncUpdate(uint32 requests) {
-  // The synchronous compositor does not requre BeginFrame messages.
-  if (!using_browser_compositor_)
-    requests &= FLUSH_INPUT;
-
   bool should_request_vsync = !outstanding_vsync_requests_ && requests;
   outstanding_vsync_requests_ |= requests;
 
   // If the host has been hidden, defer vsync requests until it is shown
   // again via |Show()|.
   if (!host_ || host_->is_hidden())
     return;
 
   // Note that if we're not currently observing the root window, outstanding
   // vsync requests will be pushed if/when we resume observing in
@@ skipping 27 matching lines @@
     return;
 
   observing_root_window_ = false;
   content_view_core_->GetWindowAndroid()->RemoveObserver(this);
 }
 
 void RenderWidgetHostViewAndroid::SendBeginFrame(base::TimeTicks frame_time,
                                                  base::TimeDelta vsync_period) {
   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::SendBeginFrame",
                "frame_time_us", frame_time.ToInternalValue());
-  base::TimeTicks display_time = frame_time + vsync_period;
 
-  base::TimeTicks deadline =
-      display_time - host_->GetEstimatedBrowserCompositeTime();
+  if (using_browser_compositor_) {
+    base::TimeTicks display_time = frame_time + vsync_period;
 
-  host_->Send(new ViewMsg_BeginFrame(
-      host_->GetRoutingID(),
-      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
-                                 vsync_period, cc::BeginFrameArgs::NORMAL)));
+    base::TimeTicks deadline =
+        display_time - host_->GetEstimatedBrowserCompositeTime();
+
+    host_->Send(new ViewMsg_BeginFrame(
+        host_->GetRoutingID(),
+        cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
+                                   vsync_period, cc::BeginFrameArgs::NORMAL)));
+  } else {
+    SynchronousCompositorImpl* compositor = SynchronousCompositorImpl::FromID(

[jdduke (slow), 2015/04/01 16:01:14]

Hmm, the other places we use SynchronousCompositorImpl we always check for null.
Should we be doing that here as well?

[sunnyps, 2015/04/01 19:53:02]

Done.

+        host_->GetProcess()->GetID(), host_->GetRoutingID());
+

[jdduke (slow), 2015/04/01 16:01:15]

Can you add a note here briefly mentioning why the SynchronousCompositor doesn't
use the deadline?

[sunnyps, 2015/04/01 19:53:02]

Done.

+    compositor->SendBeginFrame(cc::BeginFrameArgs::Create(

[jdduke (slow), 2015/04/01 16:01:15]

I'm sure this has already been covered, but why is this called |SendBeginFrame|
instead of just |BeginFrame|?

[sunnyps, 2015/04/01 19:53:01]

Done.

+        BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks(), vsync_period,
+        cc::BeginFrameArgs::NORMAL));
+  }
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate = false;
   if (overscroll_controller_) {
     needs_animate |= overscroll_controller_->Animate(
         frame_time, content_view_core_->GetLayer().get());
   }
   if (selection_controller_)
     needs_animate |= selection_controller_->Animate(frame_time);
@@ skipping 314 matching lines @@
   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
   overscroll_controller_.reset();
 }
 
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_ || host_->is_hidden())
     return;
 
-  const uint32 current_vsync_requests = outstanding_vsync_requests_;
-  outstanding_vsync_requests_ = 0;
+  if (outstanding_vsync_requests_ & FLUSH_INPUT) {
+    outstanding_vsync_requests_ &= ~FLUSH_INPUT;
+    host_->FlushInput();
+  }
 
-  if (current_vsync_requests & FLUSH_INPUT)
-    host_->FlushInput();
-
-  if (current_vsync_requests & BEGIN_FRAME ||
-      current_vsync_requests & PERSISTENT_BEGIN_FRAME) {
+  if (outstanding_vsync_requests_ & BEGIN_FRAME ||
+      outstanding_vsync_requests_ & PERSISTENT_BEGIN_FRAME) {
+    outstanding_vsync_requests_ &= ~BEGIN_FRAME;
     SendBeginFrame(frame_time, vsync_period);
   }
 
-  if (current_vsync_requests & PERSISTENT_BEGIN_FRAME)
-    RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
+  // This allows for SendBeginFrame to modify outstanding_vsync_requests.

[jdduke (slow), 2015/04/01 16:01:14]

"allows for SendBeginFrame and FlushInput"

[sunnyps, 2015/04/01 19:53:02]

Done.

+  uint32 outstanding_vsync_requests = outstanding_vsync_requests_;
+  outstanding_vsync_requests_ = 0;
+  RequestVSyncUpdate(outstanding_vsync_requests);
 }
 
 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
   if (Animate(begin_frame_time))
     SetNeedsAnimate();
 }
 
 void RenderWidgetHostViewAndroid::OnActivityPaused() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAndroid::OnActivityPaused");
   DCHECK(is_showing_);
@@ skipping 148 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content