[Android] Stop hiding the RWHV layer subtree when hiding the widget

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 374 matching lines @@
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       gesture_provider_(CreateGestureProviderConfig(), this),
       stylus_text_selector_(this),
       accelerated_surface_route_id_(0),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
+      should_unlock_surface_on_visibility_lost_or_activity_resumed_(false),
       weak_ptr_factory_(this) {
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
   DCHECK(readbacks_waiting_for_frame_.empty());
   if (resource_collection_.get())
@@ skipping 296 matching lines @@
     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() {
+  should_unlock_surface_on_visibility_lost_or_activity_resumed_ = false;
   if (!frame_evictor_->HasFrame()) {
     DCHECK_EQ(locks_on_frame_count_, 0u);
     return;
   }
   while (locks_on_frame_count_ > 0) {
     UnlockCompositingSurface();
   }
   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
 }
 
@@ skipping 1153 matching lines @@
     overscroll_controller_ = CreateOverscrollController(content_view_core_);
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
   DCHECK(using_browser_compositor_);
   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
   overscroll_controller_.reset();
 }
 
+void RenderWidgetHostViewAndroid::OnVisibilityChanged(bool visible) {
+  if (visible)

[jdduke (slow), 2015/03/16 16:54:12]

We never see this callback, as we stop observing the window when we're hidden.

[no sievers, 2015/03/17 21:37:47]

Maybe that's ok. If somebody called Hide() we already dropped everything and
shouldn't be visible anymore.

+    return;
+
+  if (should_unlock_surface_on_visibility_lost_or_activity_resumed_) {

[no sievers, 2015/03/17 21:37:47]

nit: maybe |surface_locked_for_paused_activity_| or so?

+    should_unlock_surface_on_visibility_lost_or_activity_resumed_ = false;
+    DCHECK_GT(locks_on_frame_count_, 0U);
+    UnlockCompositingSurface();
+  }
+}
+
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_)
     return;
 
   const uint32 current_vsync_requests = outstanding_vsync_requests_;
   outstanding_vsync_requests_ = 0;
 
   if (current_vsync_requests & FLUSH_INPUT)
     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);
 }
 
 void RenderWidgetHostViewAndroid::OnAnimate(base::TimeTicks begin_frame_time) {
   if (Animate(begin_frame_time))
     SetNeedsAnimate();
 }
 
+void RenderWidgetHostViewAndroid::OnActivityResumed() {
+  if (should_unlock_surface_on_visibility_lost_or_activity_resumed_) {
+    should_unlock_surface_on_visibility_lost_or_activity_resumed_ = false;
+    DCHECK_GT(locks_on_frame_count_, 0U);
+    UnlockCompositingSurface();
+  }
+}
+
+void RenderWidgetHostViewAndroid::OnActivityPaused() {
+  if (IsShowing()) {
+    DCHECK(!should_unlock_surface_on_visibility_lost_or_activity_resumed_);
+    should_unlock_surface_on_visibility_lost_or_activity_resumed_ = true;
+    LockCompositingSurface();
+  }
+}
+
 void RenderWidgetHostViewAndroid::OnLostResources() {
   ReleaseLocksOnSurface();
   if (layer_.get())
     DestroyDelegatedContent();
   DCHECK(ack_callbacks_.empty());
   // We should not loose a frame if we have readback requests pending.
   DCHECK(readbacks_waiting_for_frame_.empty());
 }
 
 // static
@@ skipping 127 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