Mac: Clean up visibility state tracking

content/browser/renderer_host/browser_compositor_view_mac.mm

 // 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 "content/browser/renderer_host/browser_compositor_view_mac.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/compositor/image_transport_factory.h"
+#include "content/browser/renderer_host/resize_lock.h"
 #include "content/public/browser/context_factory.h"
 #include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace content {
 
 namespace {
 
@@ skipping 118 matching lines @@
   // RecyclableCompositorMac that we just populated.
   if (!g_browser_compositor_count)
     g_spare_recyclable_compositor.Get().reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserCompositorMac
 
 BrowserCompositorMac::BrowserCompositorMac(
     ui::AcceleratedWidgetMacNSView* accelerated_widget_mac_ns_view,
-    DelegatedFrameHostClient* delegated_frame_host_client,
+    BrowserCompositorMacClient* client,
     bool render_widget_host_is_hidden,
     bool ns_view_attached_to_window)
-    : accelerated_widget_mac_ns_view_(accelerated_widget_mac_ns_view),
+    : client_(client),
+      accelerated_widget_mac_ns_view_(accelerated_widget_mac_ns_view),
       weak_factory_(this) {
   g_browser_compositor_count += 1;
 
   root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
-  delegated_frame_host_.reset(
-      new DelegatedFrameHost(delegated_frame_host_client));
+  delegated_frame_host_.reset(new DelegatedFrameHost(this));
 
   SetRenderWidgetHostIsHidden(render_widget_host_is_hidden);
   SetNSViewAttachedToWindow(ns_view_attached_to_window);
 }
 
 BrowserCompositorMac::~BrowserCompositorMac() {
-  DCHECK(has_been_destroyed_);
-}
-
-void BrowserCompositorMac::Destroy() {
-  if (has_been_destroyed_)
-    return;
+  // Ensure that copy callbacks completed or cancelled during further tear-down
+  // do not call back into this.
+  weak_factory_.InvalidateWeakPtrs();
 
   TransitionToState(HasNoCompositor);
   delegated_frame_host_.reset();
   root_layer_.reset();
-  has_been_destroyed_ = true;
 
   DCHECK_GT(g_browser_compositor_count, 0u);
   g_browser_compositor_count -= 1;
 
   // If there are no compositors allocated, destroy the recyclable
   // RecyclableCompositorMac.
   if (!g_browser_compositor_count)
     g_spare_recyclable_compositor.Get().reset();
 }
 
 ui::AcceleratedWidgetMac* BrowserCompositorMac::GetAcceleratedWidgetMac() {
   if (recyclable_compositor_)
     return recyclable_compositor_->accelerated_widget_mac();
   return nullptr;
 }
 
-ui::Layer* BrowserCompositorMac::GetRootLayer() {
-  return root_layer_.get();
-}
-
 DelegatedFrameHost* BrowserCompositorMac::GetDelegatedFrameHost() {
   DCHECK(delegated_frame_host_);
   return delegated_frame_host_.get();
 }
 
 void BrowserCompositorMac::CopyCompleted(
     base::WeakPtr<BrowserCompositorMac> browser_compositor,
     const ReadbackRequestCallback& callback,
     const SkBitmap& bitmap,
     ReadbackResponse response) {
@@ skipping 43 matching lines @@
   auto callback_with_decrement =
       base::Bind(&BrowserCompositorMac::CopyToVideoFrameCompleted,
                  weak_factory_.GetWeakPtr(), callback);
 
   delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
       src_subrect, target, callback_with_decrement);
 }
 
 void BrowserCompositorMac::SwapCompositorFrame(uint32_t output_surface_id,
                                                cc::CompositorFrame frame) {
-  DCHECK(!has_been_destroyed_);
-
   // 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();
   float scale_factor = frame.metadata.device_scale_factor;
   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 (recyclable_compositor_) {
     recyclable_compositor_->compositor()->SetScaleAndSize(scale_factor,
                                                           pixel_size);
   }
   delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
                                             std::move(frame));
 }
 
 void BrowserCompositorMac::SetHasTransparentBackground(bool transparent) {
-  DCHECK(!has_been_destroyed_);
   has_transparent_background_ = transparent;
   if (recyclable_compositor_) {
     recyclable_compositor_->compositor()->SetHostHasTransparentBackground(
         has_transparent_background_);
   }
 }
 
 void BrowserCompositorMac::UpdateVSyncParameters(
     const base::TimeTicks& timebase,
     const base::TimeDelta& interval) {
-  DCHECK(!has_been_destroyed_);
   if (recyclable_compositor_) {
     recyclable_compositor_->compositor()
         ->vsync_manager()
         ->UpdateVSyncParameters(timebase, interval);
   }
 }
 
 void BrowserCompositorMac::SetRenderWidgetHostIsHidden(bool hidden) {
   render_widget_host_is_hidden_ = hidden;
   UpdateState();
 }
 
 void BrowserCompositorMac::SetNSViewAttachedToWindow(bool attached) {
   ns_view_attached_to_window_ = attached;
   UpdateState();
 }
 
 void BrowserCompositorMac::UpdateState() {
-  if (has_been_destroyed_) {
-    DCHECK(state_ == HasNoCompositor);
-    return;
-  }
-
   if (!render_widget_host_is_hidden_ || outstanding_copy_count_ > 0)
     TransitionToState(HasAttachedCompositor);
   else if (ns_view_attached_to_window_)
     TransitionToState(HasDetachedCompositor);
   else
     TransitionToState(HasNoCompositor);
 }
 
 void BrowserCompositorMac::TransitionToState(State new_state) {
   // Transition HasNoCompositor -> HasDetachedCompositor.
@@ skipping 48 matching lines @@
     state_ = HasNoCompositor;
   }
 }
 
 // static
 void BrowserCompositorMac::DisableRecyclingForShutdown() {
   g_has_shut_down = true;
   g_spare_recyclable_compositor.Get().reset();
 }
 
+void BrowserCompositorMac::SetNeedsBeginFrames(bool needs_begin_frames) {
+  if (needs_begin_frames_ == needs_begin_frames)
+    return;
+
+  needs_begin_frames_ = needs_begin_frames;
+  if (begin_frame_source_) {
+    if (needs_begin_frames_)
+      begin_frame_source_->AddObserver(this);
+    else
+      begin_frame_source_->RemoveObserver(this);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DelegatedFrameHost, public:
+
+ui::Layer* BrowserCompositorMac::DelegatedFrameHostGetLayer() const {
+  return root_layer_.get();
+}
+
+bool BrowserCompositorMac::DelegatedFrameHostIsVisible() const {
+  return state_ == HasAttachedCompositor;
+}
+
+SkColor BrowserCompositorMac::DelegatedFrameHostGetGutterColor(
+    SkColor color) const {
+  return client_->BrowserCompositorMacGetGutterColor(color);
+}
+
+gfx::Size BrowserCompositorMac::DelegatedFrameHostDesiredSizeInDIP() const {
+  NSRect bounds = [client_->BrowserCompositorMacGetNSView() bounds];
+  return gfx::Size(bounds.size.width, bounds.size.height);
+}
+
+bool BrowserCompositorMac::DelegatedFrameCanCreateResizeLock() const {
+  // Mac uses the RenderWidgetResizeHelper instead of a resize lock.
+  return false;
+}
+
+std::unique_ptr<ResizeLock>
+BrowserCompositorMac::DelegatedFrameHostCreateResizeLock(
+    bool defer_compositor_lock) {
+  NOTREACHED();
+  return std::unique_ptr<ResizeLock>();
+}
+
+void BrowserCompositorMac::DelegatedFrameHostResizeLockWasReleased() {
+  NOTREACHED();
+}
+
+void BrowserCompositorMac::DelegatedFrameHostSendCompositorSwapAck(
+    int output_surface_id,
+    const cc::CompositorFrameAck& ack) {
+  client_->BrowserCompositorMacSendCompositorSwapAck(output_surface_id, ack);
+}
+
+void BrowserCompositorMac::DelegatedFrameHostSendReclaimCompositorResources(
+    int output_surface_id,
+    const cc::CompositorFrameAck& ack) {
+  client_->BrowserCompositorMacSendReclaimCompositorResources(output_surface_id,
+                                                              ack);
+}
+
+void BrowserCompositorMac::DelegatedFrameHostOnLostCompositorResources() {
+  client_->BrowserCompositorMacOnLostCompositorResources();
+}
+
+void BrowserCompositorMac::DelegatedFrameHostUpdateVSyncParameters(
+    const base::TimeTicks& timebase,
+    const base::TimeDelta& interval) {
+  client_->BrowserCompositorMacUpdateVSyncParameters(timebase, interval);
+}
+
+void BrowserCompositorMac::SetBeginFrameSource(cc::BeginFrameSource* source) {
+  if (begin_frame_source_ && needs_begin_frames_)
+    begin_frame_source_->RemoveObserver(this);
+  begin_frame_source_ = source;
+  if (begin_frame_source_ && needs_begin_frames_)
+    begin_frame_source_->AddObserver(this);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// cc::BeginFrameSourceBase, public:
+
+void BrowserCompositorMac::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  delegated_frame_host_->SetVSyncParameters(args.frame_time, args.interval);
+  client_->BrowserCompositorMacSendBeginFrame(args);
+  last_begin_frame_args_ = args;
+}
+
+const cc::BeginFrameArgs& BrowserCompositorMac::LastUsedBeginFrameArgs() const {
+  return last_begin_frame_args_;
+}
+
+void BrowserCompositorMac::OnBeginFrameSourcePausedChanged(bool paused) {
+  // Only used on Android WebView.
+}
+
 }  // namespace content