mac: ensure ui::Compositor exists for visible RWHVs

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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_mac.h"
 
 #import <objc/runtime.h>
 #include <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
 #include <stdint.h>
@@ skipping 579 matching lines @@
     render_widget_host_->SetView(this);
 
   // Let the page-level input event router know about our surface ID
   // namespace for surface-based hit testing.
   if (render_widget_host_->delegate() &&
       render_widget_host_->delegate()->GetInputEventRouter()) {
     render_widget_host_->delegate()
         ->GetInputEventRouter()
         ->AddSurfaceIdNamespaceOwner(GetSurfaceIdNamespace(), this);
   }
+
+  if (!render_widget_host_->is_hidden())
+    EnsureBrowserCompositorView();
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   display::Screen::GetScreen()->RemoveObserver(this);
 
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
   UnlockMouse();
@@ skipping 23 matching lines @@
 }
 
 cc::SurfaceId RenderWidgetHostViewMac::SurfaceIdForTesting() const {
   return delegated_frame_host_->SurfaceIdForTesting();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
 
 void RenderWidgetHostViewMac::EnsureBrowserCompositorView() {
+  DCHECK(!render_widget_host_->is_hidden());
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::EnsureBrowserCompositorView");
 
   // Create the view, to transition from Destroyed -> Suspended.
   if (browser_compositor_state_ == BrowserCompositorDestroyed) {
     browser_compositor_ = BrowserCompositorMac::Create();
     browser_compositor_->compositor()->SetRootLayer(root_layer_.get());
     browser_compositor_->compositor()->SetHostHasTransparentBackground(
         !GetBackgroundOpaque());
     browser_compositor_->accelerated_widget_mac()->SetNSView(this);
@@ skipping 56 matching lines @@
 
   // If this view is in a window that is visible, keep around the suspended
   // BrowserCompositorView in case |cocoa_view_| is suddenly revealed (so that
   // we don't flash white).
   NSWindow* window = [cocoa_view_ window];
   if (window)
     return;
 
   // This should only be reached if |render_widget_host_| is hidden, destroyed,
   // or in the process of being destroyed.
+  DCHECK(!render_widget_host_ || render_widget_host_->is_hidden());
   DestroyBrowserCompositorView();
 }
 
 bool RenderWidgetHostViewMac::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewMac, message)
     IPC_MESSAGE_HANDLER(ViewMsg_GetRenderedTextCompleted,
         OnGetRenderedTextCompleted)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrames,
                         OnSetNeedsBeginFrames)
@@ skipping 151 matching lines @@
   render_widget_host_->NotifyScreenInfoChanged();
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::Show() {
   ScopedCAActionDisabler disabler;
   [cocoa_view_ setHidden:NO];
-  if (!render_widget_host_->is_hidden())
+  if (!render_widget_host_->is_hidden()) {
+    DCHECK_EQ(browser_compositor_state_, BrowserCompositorActive);
     return;
+  }
+
+  WasUnOccluded();
 
   // Re-create the browser compositor. If the DelegatedFrameHost has a cached
   // frame from the last time it was visible, then it will immediately be
   // drawn. If not, then the compositor will remain locked until a new delegated
   // frame is swapped.
   EnsureBrowserCompositorView();
 
-  WasUnOccluded();
-
   // If there is not a frame being currently drawn, kick one, so that the below
   // pause will have a frame to wait on.
   render_widget_host_->ScheduleComposite();
   PauseForPendingResizeOrRepaintsAndDraw();
 }
 
 void RenderWidgetHostViewMac::Hide() {
   ScopedCAActionDisabler disabler;
   [cocoa_view_ setHidden:YES];
   if (!render_widget_host_->is_hidden()) {
     // Note that the following call to WasHidden() can trigger thumbnail
     // generation on behalf of the NTP, and that cannot succeed if the browser
     // compositor view has been suspended. Therefore these two statements must
     // occur in this specific order. However, because thumbnail generation is
     // asychronous, that operation won't run before
     // SuspendBrowserCompositorView()
     // completes. As a result you won't get a thumbnail for the page unless you
     // execute these two statements in this specific order.
     render_widget_host_->WasHidden();
+    // Re-check hidden flag, as the thumbnail generation could have called

[enne (OOO), 2016/06/15 22:07:44]

This was the cause of the white tabs.  I added a bunch more dchecks to try to
avoid this.  Show now makes sure that if it early outs, that the browser is
already created.  Creating and destroying the browser compositor also verify
that the RWH hidden state is as expected.

This also fixes the webrtc regression.  The tab switching test was extremely
noisy when run locally but it looked slightly better with this change, so will
reland and see what the bots look like.

+    // WasUnOccluded and unhidden itself.
+    if (!render_widget_host_->is_hidden()) {
+      return;
+    }
     SuspendBrowserCompositorView();
   }
   DestroySuspendedBrowserCompositorViewIfNeeded();
 }
 
 void RenderWidgetHostViewMac::WasUnOccluded() {
   if (!render_widget_host_->is_hidden())
     return;
 
   ui::LatencyInfo renderer_latency_info;
   renderer_latency_info.AddLatencyNumber(
       ui::TAB_SHOW_COMPONENT,
       render_widget_host_->GetLatencyComponentId(),
       0);
   render_widget_host_->WasShown(renderer_latency_info);
+  EnsureBrowserCompositorView();
 }
 
 void RenderWidgetHostViewMac::WasOccluded() {
   if (render_widget_host_->is_hidden())
     return;
 
   // Ignore occlusion when in fullscreen low power mode, because the occlusion
   // is likely coming from the fullscreen low power window.
   if (browser_compositor_) {
     if (browser_compositor_->accelerated_widget_mac()
@@ skipping 542 matching lines @@
   if (frame->delegated_frame_data) {
     float scale_factor = frame->metadata.device_scale_factor;
 
     // Compute the frame size based on the root render pass rect size.
     cc::RenderPass* root_pass =
         frame->delegated_frame_data->render_pass_list.back().get();
     gfx::Size pixel_size = root_pass->output_rect.size();
     gfx::Size dip_size = gfx::ConvertSizeToDIP(scale_factor, pixel_size);
 
     root_layer_->SetBounds(gfx::Rect(dip_size));
-    if (!render_widget_host_->is_hidden()) {
-      EnsureBrowserCompositorView();
+    if (browser_compositor_ && browser_compositor_->compositor()) {
       browser_compositor_->compositor()->SetScaleAndSize(
           scale_factor, pixel_size);
     }
 
     SendVSyncParametersToRenderer();
 
     delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
                                               std::move(frame));
   } else {
     DLOG(ERROR) << "Received unexpected frame type.";
@@ skipping 1933 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end