Revert of 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 732 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;
 
-  if (using_browser_compositor_) {
-    base::TimeTicks display_time = frame_time + vsync_period;
+  base::TimeTicks deadline =
+      display_time - host_->GetEstimatedBrowserCompositeTime();
 
-    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(
-        host_->GetProcess()->GetID(), host_->GetRoutingID());
-    if (compositor) {
-      // The synchronous compositor synchronously does it's work in this call.
-      // It does not use a deadline.
-      compositor->BeginFrame(cc::BeginFrameArgs::Create(
-          BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks(), vsync_period,
-          cc::BeginFrameArgs::NORMAL));
-    }
-  }
+  host_->Send(new ViewMsg_BeginFrame(
+      host_->GetRoutingID(),
+      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
+                                 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;
 
-  if (outstanding_vsync_requests_ & FLUSH_INPUT) {
-    outstanding_vsync_requests_ &= ~FLUSH_INPUT;
+  const uint32 current_vsync_requests = outstanding_vsync_requests_;
+  outstanding_vsync_requests_ = 0;
+
+  if (current_vsync_requests & FLUSH_INPUT)
     host_->FlushInput();
-  }
 
-  if (outstanding_vsync_requests_ & BEGIN_FRAME ||
-      outstanding_vsync_requests_ & PERSISTENT_BEGIN_FRAME) {
-    outstanding_vsync_requests_ &= ~BEGIN_FRAME;
+  if (current_vsync_requests & BEGIN_FRAME ||
+      current_vsync_requests & PERSISTENT_BEGIN_FRAME) {
     SendBeginFrame(frame_time, vsync_period);
   }
 
-  // This allows for SendBeginFrame and FlushInput to modify
-  // outstanding_vsync_requests.
-  uint32 outstanding_vsync_requests = outstanding_vsync_requests_;
-  outstanding_vsync_requests_ = 0;
-  RequestVSyncUpdate(outstanding_vsync_requests);
+  if (current_vsync_requests & PERSISTENT_BEGIN_FRAME)
+    RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
 }
 
 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