Revert of [Android] Consolidate vsync request logic in RWHVAndroid

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 227 matching lines @@
     uint32 output_id,
     scoped_ptr<cc::CompositorFrame> output_frame)
     : output_surface_id(output_id), frame(output_frame.Pass()) {}
 
 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
-      outstanding_vsync_requests_(0),
+      needs_begin_frame_(false),
       is_showing_(!widget_host->is_hidden()),
       content_view_core_(NULL),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       weak_ptr_factory_(this),
       overscroll_effect_enabled_(
           !base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableOverscrollEdgeEffect)),
       gesture_provider_(CreateGestureProviderConfig(), this),
       gesture_text_selector_(this),
       touch_scrolling_(false),
       potentially_active_fling_count_(0),
+      flush_input_requested_(false),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false) {
   host_->SetView(this);
   SetContentViewCore(content_view_core);
   ImageTransportFactoryAndroid::AddObserver(this);
@@ skipping 43 matching lines @@
 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasShown() {
   if (!host_ || !host_->is_hidden())
     return;
 
   host_->WasShown(ui::LatencyInfo());
 
-  if (content_view_core_) {
-    StartObservingRootWindow();
-    RequestVSyncUpdate(BEGIN_FRAME);
+  if (content_view_core_ && !using_synchronous_compositor_) {
+    content_view_core_->GetWindowAndroid()->AddObserver(this);
+    content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
+    observing_root_window_ = true;
   }
 }
 
 void RenderWidgetHostViewAndroid::WasHidden() {
   RunAckCallbacks();
 
   if (!host_ || host_->is_hidden())
     return;
 
   // Inform the renderer that we are being hidden so it can reduce its resource
   // utilization.
   host_->WasHidden();
 
-  StopObservingRootWindow();
+  if (content_view_core_ && !using_synchronous_compositor_) {
+    content_view_core_->GetWindowAndroid()->RemoveObserver(this);
+    observing_root_window_ = false;
+  }
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
   host_->WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   default_size_ = size;
@@ skipping 264 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::OnSetNeedsBeginFrame(bool enabled) {
-  DCHECK(!using_synchronous_compositor_);
+  if (enabled == needs_begin_frame_)
+    return;
+
   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::OnSetNeedsBeginFrame",
                "enabled", enabled);
-  if (enabled)
-    RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
-  else
-    outstanding_vsync_requests_ &= ~PERSISTENT_BEGIN_FRAME;
+  if (content_view_core_ && enabled)
+    content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
+
+  needs_begin_frame_ = enabled;
 }
 
 void RenderWidgetHostViewAndroid::OnStartContentIntent(
     const GURL& content_url) {
   if (content_view_core_)
     content_view_core_->StartContentIntent(content_url);
 }
 
 void RenderWidgetHostViewAndroid::OnSmartClipDataExtracted(
     const base::string16& text,
@@ skipping 600 matching lines @@
     return;
 
   if (!layer_.get())
     return;
 
   content_view_core_->RemoveLayer(layer_);
   if (overscroll_effect_)
     overscroll_effect_->Disable();
 }
 
-void RenderWidgetHostViewAndroid::RequestVSyncUpdate(uint32 requests) {
-  // The synchronous compositor does not requre BeginFrame messages.
-  if (using_synchronous_compositor_)
-    requests &= FLUSH_INPUT;
-
-  bool should_request_vsync = !outstanding_vsync_requests_ && requests;
-  outstanding_vsync_requests_ |= requests;
-  // Note that if we're not currently observing the root window, outstanding
-  // vsync requests will be pushed if/when we resume observing in
-  // |StartObservingRootWindow()|.
-  if (observing_root_window_ && should_request_vsync)
-    content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
-}
-
-void RenderWidgetHostViewAndroid::StartObservingRootWindow() {
-  DCHECK(content_view_core_);
-  DCHECK(!observing_root_window_);
-  observing_root_window_ = true;
-  content_view_core_->GetWindowAndroid()->AddObserver(this);
-
-  // Clear existing vsync requests to allow a request to the new window.
-  uint32 outstanding_vsync_requests = outstanding_vsync_requests_;
-  outstanding_vsync_requests_ = 0;
-  RequestVSyncUpdate(outstanding_vsync_requests);
-}
-
-void RenderWidgetHostViewAndroid::StopObservingRootWindow() {
-  if (!content_view_core_) {
-    DCHECK(!observing_root_window_);
-    return;
-  }
-
-  if (!observing_root_window_)
-    return;
-
-  observing_root_window_ = false;
-  content_view_core_->GetWindowAndroid()->RemoveObserver(this);
-}
-
-void RenderWidgetHostViewAndroid::SendBeginFrame(base::TimeTicks frame_time,
-                                                 base::TimeDelta vsync_period) {
-  TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::SendBeginFrame");
-  base::TimeTicks display_time = frame_time + vsync_period;
-
-  // TODO(brianderson): Use adaptive draw-time estimation.
-  base::TimeDelta estimated_browser_composite_time =
-      base::TimeDelta::FromMicroseconds(
-          (1.0f * base::Time::kMicrosecondsPerSecond) / (3.0f * 60));
-
-  base::TimeTicks deadline = display_time - estimated_browser_composite_time;
-
-  host_->Send(new ViewMsg_BeginFrame(
-      host_->GetRoutingID(),
-      cc::BeginFrameArgs::Create(frame_time, deadline, vsync_period)));
-}
-
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate =
       overscroll_effect_ ? overscroll_effect_->Animate(frame_time) : false;
   if (selection_controller_)
     needs_animate |= selection_controller_->Animate(frame_time);
   return needs_animate;
 }
 
 void RenderWidgetHostViewAndroid::OnContentScrollingChange() {
   if (selection_controller_)
@@ skipping 128 matching lines @@
 
   SynchronousCompositorImpl* compositor =
       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
                                           host_->GetRoutingID());
   if (compositor)
     return compositor->HandleInputEvent(input_event);
   return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
 void RenderWidgetHostViewAndroid::OnSetNeedsFlushInput() {
+  if (flush_input_requested_ || !content_view_core_)
+    return;
   TRACE_EVENT0("input", "RenderWidgetHostViewAndroid::OnSetNeedsFlushInput");
-  RequestVSyncUpdate(FLUSH_INPUT);
+  flush_input_requested_ = true;
+  content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostViewAndroid::CreateBrowserAccessibilityManager(
         BrowserAccessibilityDelegate* delegate) {
   base::android::ScopedJavaLocalRef<jobject> obj;
   if (content_view_core_)
     obj = content_view_core_->GetJavaObject();
   return new BrowserAccessibilityManagerAndroid(
       obj,
@@ skipping 20 matching lines @@
 
 void RenderWidgetHostViewAndroid::SendTouchEvent(
     const blink::WebTouchEvent& event) {
   if (host_)
     host_->ForwardTouchEventWithLatencyInfo(event, CreateLatencyInfo(event));
 
   // Send a proactive BeginFrame on the next vsync to reduce latency.
   // This is good enough as long as the first touch event has Begin semantics
   // and the actual scroll happens on the next vsync.
   // TODO: Is this actually still needed?
-  if (observing_root_window_)
-    RequestVSyncUpdate(BEGIN_FRAME);
+  if (content_view_core_ && observing_root_window_) {
+    content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
+  }
 }
 
 void RenderWidgetHostViewAndroid::SendMouseEvent(
     const blink::WebMouseEvent& event) {
   if (host_)
     host_->ForwardMouseEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SendMouseWheelEvent(
     const blink::WebMouseWheelEvent& event) {
@@ skipping 75 matching lines @@
     OnContentScrollingChange();
   }
 
   if (content_view_core_)
     content_view_core_->DidStopFlinging();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RemoveLayers();
-  StopObservingRootWindow();
+  if (observing_root_window_ && content_view_core_) {
+    content_view_core_->GetWindowAndroid()->RemoveObserver(this);
+    observing_root_window_ = false;
+  }
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
     selection_controller_.reset();
     ReleaseLocksOnSurface();
     resize = true;
   }
 
   content_view_core_ = content_view_core;
 
   BrowserAccessibilityManager* manager = NULL;
   if (host_)
     manager = host_->GetRootBrowserAccessibilityManager();
   if (manager) {
     base::android::ScopedJavaLocalRef<jobject> obj;
     if (content_view_core_)
       obj = content_view_core_->GetJavaObject();
     manager->ToBrowserAccessibilityManagerAndroid()->SetContentViewCore(obj);
   }
 
   AttachLayers();
 
   if (!content_view_core_)
     return;
 
-  StartObservingRootWindow();
+  if (!using_synchronous_compositor_) {
+    content_view_core_->GetWindowAndroid()->AddObserver(this);
+    observing_root_window_ = true;
+    if (needs_begin_frame_)
+      content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
+  }
 
   if (resize)
     WasResized();
 
   if (!selection_controller_)
     selection_controller_.reset(new TouchSelectionController(this));
 
   if (!content_view_core_)
     overscroll_effect_.reset();
   else if (overscroll_effect_enabled_ && !overscroll_effect_)
@@ skipping 24 matching lines @@
   DCHECK(!using_synchronous_compositor_);
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_)
     return;
 
-  const uint32 current_vsync_requests = outstanding_vsync_requests_;
-  outstanding_vsync_requests_ = 0;
-
-  if (current_vsync_requests & FLUSH_INPUT)
+  if (flush_input_requested_) {
+    flush_input_requested_ = false;
     host_->FlushInput();
-
-  if (current_vsync_requests & BEGIN_FRAME ||
-      current_vsync_requests & PERSISTENT_BEGIN_FRAME) {
-    SendBeginFrame(frame_time, vsync_period);
   }
 
-  if (current_vsync_requests & PERSISTENT_BEGIN_FRAME)
-    RequestVSyncUpdate(PERSISTENT_BEGIN_FRAME);
+  TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::SendBeginFrame");
+  base::TimeTicks display_time = frame_time + vsync_period;
+
+  // TODO(brianderson): Use adaptive draw-time estimation.
+  base::TimeDelta estimated_browser_composite_time =
+      base::TimeDelta::FromMicroseconds(
+          (1.0f * base::Time::kMicrosecondsPerSecond) / (3.0f * 60));
+
+  base::TimeTicks deadline = display_time - estimated_browser_composite_time;
+
+  host_->Send(new ViewMsg_BeginFrame(
+      host_->GetRoutingID(),
+      cc::BeginFrameArgs::Create(frame_time, deadline, vsync_period)));
+
+  if (needs_begin_frame_)
+    content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
 }
 
 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
   if (Animate(begin_frame_time))
     SetNeedsAnimate();
 }
 
 void RenderWidgetHostViewAndroid::OnLostResources() {
   ReleaseLocksOnSurface();
   if (layer_.get())
@@ skipping 135 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