content: Remove Lock/Unlock CompositingSurface API from RWH.

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 <utility>
 
@@ skipping 424 matching lines @@
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_compositor_frame_sink_id_(kUndefinedCompositorFrameSinkId),
       gesture_provider_(ui::GetGestureProviderConfig(
                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
                         this),
       stylus_text_selector_(this),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       synchronous_compositor_client_(nullptr),
       frame_evictor_(new DelegatedFrameEvictor(this)),
-      locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
   // Set the layer which will hold the content layer for this view. The content
   // layer is managed by the DelegatedFrameHost.
   view_.SetLayer(cc::Layer::Create());
   if (using_browser_compositor_) {
     delegated_frame_host_.reset(new ui::DelegatedFrameHostAndroid(
         &view_, cached_background_color_, this));
   }
 
@@ skipping 167 matching lines @@
   HideInternal();
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
   // ContentViewCoreImpl represents the native side of the Java
   // ContentViewCore.  It being NULL means that it is not attached
   // to the View system yet, so we treat this RWHVA as hidden.
   return is_showing_ && content_view_core_;
 }
 
-void RenderWidgetHostViewAndroid::LockCompositingSurface() {
-  DCHECK(HasValidFrame());
-  DCHECK(host_);
-  DCHECK(frame_evictor_->HasFrame());
-  frame_evictor_->LockFrame();
-  locks_on_frame_count_++;
-}
-
-void RenderWidgetHostViewAndroid::UnlockCompositingSurface() {
-  if (!frame_evictor_->HasFrame()) {
-    DCHECK_EQ(locks_on_frame_count_, 0u);
-    return;
-  }
-
-  DCHECK_GT(locks_on_frame_count_, 0u);
-  locks_on_frame_count_--;
-  frame_evictor_->UnlockFrame();
-
-  if (locks_on_frame_count_ == 0) {
-    if (last_frame_info_) {

[boliu, 2017/02/02 22:58:47]

looks like last_frame_info_ can be removed too?

[Khushal, 2017/02/02 23:25:00]

Yup. Done.

-      InternalSwapCompositorFrame(last_frame_info_->compositor_frame_sink_id,
-                                  std::move(last_frame_info_->frame));
-      last_frame_info_.reset();
-    }
-
-    view_.GetLayer()->SetHideLayerAndSubtree(!is_showing_);
-  }
-}
-
 void RenderWidgetHostViewAndroid::OnShowUnhandledTapUIIfNeeded(int x_dip,
                                                                int y_dip) {
   if (!content_view_core_)
     return;
   // Validate the coordinates are within the viewport.
   gfx::Size viewport_size = content_view_core_->GetViewportSizeDip();
   if (x_dip < 0 || x_dip > viewport_size.width() ||
       y_dip < 0 || y_dip > viewport_size.height())
     return;
   content_view_core_->OnShowUnhandledTapUIIfNeeded(x_dip, y_dip);
 }
 
-void RenderWidgetHostViewAndroid::ReleaseLocksOnSurface() {
-  if (!frame_evictor_->HasFrame()) {
-    DCHECK_EQ(locks_on_frame_count_, 0u);
-    return;
-  }
-  while (locks_on_frame_count_ > 0) {
-    UnlockCompositingSurface();
-  }
-  RunAckCallbacks();
-}
-
 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
   if (!content_view_core_)
     return default_bounds_;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableOSKOverscroll))
     return gfx::Rect(content_view_core_->GetViewSizeWithOSKHidden());
 
   return gfx::Rect(content_view_core_->GetViewSize());
 }
@@ skipping 389 matching lines @@
                                    false /* is_swap_ack */);
 
   last_compositor_frame_sink_id_ = compositor_frame_sink_id;
 }
 
 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
   DCHECK(delegated_frame_host_);
-
-  if (locks_on_frame_count_ > 0) {
-    DCHECK(HasValidFrame());
-    RetainFrame(compositor_frame_sink_id, std::move(frame));
-    return;
-  }
-
   DCHECK(!frame.render_pass_list.empty());
 
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
   current_surface_size_ = root_pass->output_rect.size();
   bool is_transparent = root_pass->has_transparent_background;
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   CheckCompositorFrameSinkChanged(compositor_frame_sink_id);
   bool has_content = !current_surface_size_.IsEmpty();
@@ skipping 21 matching lines @@
 
   // As the metadata update may trigger view invalidation, always call it after
   // any potential compositor scheduling.
   OnFrameMetadataUpdated(std::move(metadata), is_transparent);
 }
 
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
   DCHECK(!delegated_frame_host_ ||
          delegated_frame_host_->HasDelegatedContent() ==
              frame_evictor_->HasFrame());
-  DCHECK_EQ(locks_on_frame_count_, 0u);
 
   if (!delegated_frame_host_)
     return;
 
   if (!delegated_frame_host_->HasDelegatedContent())
     return;
 
   frame_evictor_->DiscardedFrame();
   delegated_frame_host_->DestroyDelegatedContent();
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   InternalSwapCompositorFrame(compositor_frame_sink_id, std::move(frame));
 }
 
 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
   DestroyDelegatedContent();
 }
 
-void RenderWidgetHostViewAndroid::RetainFrame(uint32_t compositor_frame_sink_id,
-                                              cc::CompositorFrame frame) {
-  DCHECK(locks_on_frame_count_);
-
-  // Store the incoming frame so that it can be swapped when all the locks have
-  // been released. If there is already a stored frame, then replace and skip
-  // the previous one but make sure we still eventually send the ACK. Holding
-  // the ACK also blocks the renderer when its max_frames_pending is reached.
-  if (last_frame_info_) {
-    base::Closure ack_callback = base::Bind(
-        &RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
-        weak_ptr_factory_.GetWeakPtr(),
-        last_frame_info_->compositor_frame_sink_id, true /* is_swap_ack */);
-
-    ack_callbacks_.push(ack_callback);
-  }
-
-  last_frame_info_.reset(
-      new LastFrameInfo(compositor_frame_sink_id, std::move(frame)));
-}
-
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     cc::CompositorFrameMetadata frame_metadata) {
   if (!content_view_core_)
     return;
 
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
 
   if (host_ && host_->input_router()) {
     host_->input_router()->NotifySiteIsMobileOptimized(
         is_mobile_optimized);
@@ skipping 207 matching lines @@
   // window is still visible. This avoids visual artificts when transitioning
   // between activities.
   bool hide_frontbuffer = is_window_activity_started_ || !is_window_visible_;
 
   // Only stop observing the root window if the widget has been explicitly
   // hidden and the frontbuffer is being cleared. This allows window visibility
   // notifications to eventually clear the frontbuffer.
   bool stop_observing_root_window = !is_showing_ && hide_frontbuffer;
 
   if (hide_frontbuffer) {
-    if (locks_on_frame_count_ == 0)
-      view_.GetLayer()->SetHideLayerAndSubtree(true);
-
+    view_.GetLayer()->SetHideLayerAndSubtree(true);
     frame_evictor_->SetVisible(false);
   }
 
   if (stop_observing_root_window) {
     DCHECK(!is_showing_);
     StopObservingRootWindow();
   }
 
   if (!host_ || host_->is_hidden())
     return;
@@ skipping 353 matching lines @@
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   DCHECK(!content_view_core || !content_view_core_ ||
          (content_view_core_ == content_view_core));
   StopObservingRootWindow();
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
     selection_controller_.reset();
-    ReleaseLocksOnSurface();
+    RunAckCallbacks();
     // TODO(yusufo) : Get rid of the below conditions and have a better handling
     // for resizing after crbug.com/628302 is handled.
     bool is_size_initialized = !content_view_core
         || content_view_core->GetViewportSizeDip().width() != 0
         || content_view_core->GetViewportSizeDip().height() != 0;
     if (content_view_core_ || is_size_initialized)
       resize = true;
     if (content_view_core_) {
       content_view_core_->RemoveObserver(this);
       view_.RemoveFromParent();
@@ skipping 172 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::OnActivityStarted() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAndroid::OnActivityStarted");
   DCHECK(observing_root_window_);
   is_window_activity_started_ = true;
   ShowInternal();
 }
 
 void RenderWidgetHostViewAndroid::OnLostResources() {
-  ReleaseLocksOnSurface();

[Khushal, 2017/02/02 01:46:35]

So at the other place where we were calling this, I just made it a no-op, it
would simply run the callbacks if there were no locks.

For this one, I don't think its necessary. Destroying the delegated content
should remove all references to the frame and the SurfaceManager should run the
draw callback and return resources.

   DestroyDelegatedContent();
   DCHECK(ack_callbacks_.empty());
 }
 
 void RenderWidgetHostViewAndroid::OnStylusSelectBegin(float x0,
                                                       float y0,
                                                       float x1,
                                                       float y1) {
   SelectBetweenCoordinates(gfx::PointF(x0, y0), gfx::PointF(x1, y1));
 }
@@ skipping 72 matching lines @@
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor,
       ui::GetScaleFactorForNativeView(GetNativeView()));
 }
 
 }  // namespace content