(NOT FOR COMMIT) Remove BVR cruft

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),
-      invalidate_after_composite_(false),
       block_invalidates_(false),
       fallback_tick_pending_(false) {
 }
 
 BrowserViewRenderer::~BrowserViewRenderer() {
 }
 
 SharedRendererState* BrowserViewRenderer::GetAwDrawGLViewContext() {
   return &shared_renderer_state_;
 }
@@ skipping 88 matching lines @@
   if (!hardware_enabled_) {
     TRACE_EVENT0("android_webview", "InitializeHwDraw");
     hardware_enabled_ = compositor_->InitializeHwDraw();
   }
   if (!hardware_enabled_) {
     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_HardwareNotEnabled",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  if (last_on_draw_global_visible_rect_.IsEmpty() &&
-      parent_draw_constraints_.surface_rect.IsEmpty()) {
-    TRACE_EVENT_INSTANT0("android_webview",
-                         "EarlyOut_EmptyVisibleRect",
-                         TRACE_EVENT_SCOPE_THREAD);
-    shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(true);
-    return true;
-  }
-
-  ReturnResourceFromParent();
-  if (shared_renderer_state_.HasCompositorFrameOnUI()) {
-    TRACE_EVENT_INSTANT0("android_webview",
-                         "EarlyOut_PreviousFrameUnconsumed",
-                         TRACE_EVENT_SCOPE_THREAD);
-    DidSkipCompositeInDraw();
-    return true;
-  }
-
-  scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
-  if (!frame.get()) {
-    TRACE_EVENT_INSTANT0("android_webview", "NoNewFrame",
-                         TRACE_EVENT_SCOPE_THREAD);
-    return false;
-  }
-
-  shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), false);
-  return true;
+  return CompositeHw();
 }
 
-scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
+bool BrowserViewRenderer::CompositeHw() {
+  ReturnResourceFromParent();
+
   compositor_->SetMemoryPolicy(CalculateDesiredMemoryPolicy());
 
   parent_draw_constraints_ =
       shared_renderer_state_.GetParentDrawConstraintsOnUI();
   gfx::Size surface_size(size_);
   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 ||
-      last_on_draw_global_visible_rect_.IsEmpty()) {
+  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())
-    DidComposite();
-  return frame.Pass();
+
+  if (!frame.get()) {
+    TRACE_EVENT_INSTANT0("android_webview", "NoNewFrame",
+                         TRACE_EVENT_SCOPE_THREAD);
+    return false;
+  }
+
+  DidComposite();
+  ReturnUnusedResource(shared_renderer_state_.PassUncommittedFrameOnUI());
+  shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass());
+  return true;
 }
 
-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() {
+  if (!parent_draw_constraints_.Equals(
+          shared_renderer_state_.GetParentDrawConstraintsOnUI())) {
+    PostInvalidateWithFallback();
   }
 }
 
-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);
-    PostInvalidateWithFallback(needs_force_invalidate);
-  }
-}
-
 void BrowserViewRenderer::ReturnUnusedResource(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (!frame.get())
     return;
 
   cc::CompositorFrameAck frame_ack;
   cc::TransferableResource::ReturnResources(
       frame->delegated_frame_data->resource_list, &frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty())
     compositor_->ReturnResources(frame_ack);
 }
 
 void BrowserViewRenderer::ReturnResourceFromParent() {
   cc::CompositorFrameAck frame_ack;
   shared_renderer_state_.SwapReturnedResourcesOnUI(&frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty()) {
     compositor_->ReturnResources(frame_ack);
   }
 }
 
-void BrowserViewRenderer::DidSkipCommitFrame() {
-  // Treat it the same way as skipping onDraw.
-  DidSkipCompositeInDraw();
-}
-
 void BrowserViewRenderer::InvalidateOnFunctorDestroy() {
   client_->InvalidateOnFunctorDestroy();
 }
 
 bool BrowserViewRenderer::OnDrawSoftware(SkCanvas* canvas) {
   return CanOnDraw() && CompositeSW(canvas);
 }
 
 skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
                                                             int height) {
@@ skipping 24 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.
-  PostInvalidateWithFallback(false);
+  PostInvalidateWithFallback();
 }
 
 void BrowserViewRenderer::SetIsPaused(bool paused) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "BrowserViewRenderer::SetIsPaused",
                        TRACE_EVENT_SCOPE_THREAD,
                        "paused",
                        paused);
   is_paused_ = paused;
   UpdateCompositorIsActive();
@@ skipping 251 matching lines @@
   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::PostInvalidate() {
   TRACE_EVENT_INSTANT0("android_webview", "BrowserViewRenderer::PostInvalidate",
                        TRACE_EVENT_SCOPE_THREAD);
-  PostInvalidateWithFallback(false);
+  PostInvalidateWithFallback();
 }
 
-void BrowserViewRenderer::PostInvalidateWithFallback(
-    bool skip_reschedule_tick) {
+void BrowserViewRenderer::PostInvalidateWithFallback() {
   if (block_invalidates_) {
-    invalidate_after_composite_ = true;
     return;
   }
 
   // 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_);
 
   if (throttle_fallback_tick)
     return;
 
   // 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_)
+  if (fallback_tick_pending_)
     return;
 
   post_fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::PostFallbackTick,
                                        base::Unretained(this)));
   fallback_tick_fired_.Cancel();
 
   fallback_tick_pending_ = true;
   ui_task_runner_->PostTask(FROM_HERE, post_fallback_tick_.callback());
 }
 
@@ skipping 12 matching lines @@
 }
 
 void BrowserViewRenderer::FallbackTickFired() {
   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_) {
     if (hardware_enabled_) {
-      ForceCompositeHw();
+      CompositeHw();
     } else {
       ForceFakeCompositeSW();
     }
   }
   // Pretend we just composited to unblock further invalidates.
   DidComposite();
 }
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
   DCHECK(compositor_);
@@ skipping 11 matching lines @@
   DidComposite();
   return result;
 }
 
 void BrowserViewRenderer::DidComposite() {
   block_invalidates_ = false;
 
   post_fallback_tick_.Cancel();
   fallback_tick_fired_.Cancel();
   fallback_tick_pending_ = false;
-
-  if (invalidate_after_composite_)
-    PostInvalidateWithFallback(false);
-}
-
-void BrowserViewRenderer::DidSkipCompositeInDraw() {
-  block_invalidates_ = false;
-  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, "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