Clean up the RWHVMac to ui::Compositor interface (phase 1 of 2)

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 394 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 int RenderWidgetHostViewMac::DelegatedFrameHostGetGpuMemoryBufferClientId()
     const {
   return render_widget_host_->GetProcess()->GetID();
 }
 
 ui::Layer* RenderWidgetHostViewMac::DelegatedFrameHostGetLayer() const {
-  return root_layer_.get();
+  return browser_compositor_->GetRootLayer();
 }
 
 bool RenderWidgetHostViewMac::DelegatedFrameHostIsVisible() const {
   return !render_widget_host_->is_hidden();
 }
 
 SkColor RenderWidgetHostViewMac::DelegatedFrameHostGetGutterColor(
     SkColor color) const {
   // When making an element on the page fullscreen the element's background
   // may not match the page's, so use black as the gutter color to avoid
@@ skipping 69 matching lines @@
   if (begin_frame_source_) {
     if (needs_begin_frames_)
       begin_frame_source_->AddObserver(this);
     else
       begin_frame_source_->RemoveObserver(this);
   }
 }
 
 void RenderWidgetHostViewMac::OnBeginFrame(
     const cc::BeginFrameArgs& args) {
-  delegated_frame_host_->SetVSyncParameters(args.frame_time, args.interval);
+  browser_compositor_->GetDelegatedFrameHost()->SetVSyncParameters(
+      args.frame_time, args.interval);
   render_widget_host_->Send(
       new ViewMsg_BeginFrame(render_widget_host_->GetRoutingID(), args));
   last_begin_frame_args_ = args;
 }
 
 const cc::BeginFrameArgs& RenderWidgetHostViewMac::LastUsedBeginFrameArgs()
     const {
   return last_begin_frame_args_;
 }
 
@@ skipping 33 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget,
                                                  bool is_guest_view_hack)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
-      browser_compositor_state_(BrowserCompositorDestroyed),
-      browser_compositor_placeholder_(new BrowserCompositorMacPlaceholder),
       page_at_minimum_scale_(true),
       is_loading_(false),
       allow_pause_for_resize_or_repaint_(true),
       is_guest_view_hack_(is_guest_view_hack),
       fullscreen_parent_host_view_(nullptr),
       begin_frame_source_(nullptr),
       needs_begin_frames_(false),
       weak_factory_(this) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
 
   // Paint this view host with |background_color_| when there is no content
   // ready to draw.
   background_layer_.reset([[CALayer alloc] init]);
   // Set the default color to be white. This is the wrong thing to do, but many
   // UI components expect this view to be opaque.
   [background_layer_ setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
   [cocoa_view_ setLayer:background_layer_];
   [cocoa_view_ setWantsLayer:YES];
 
-  root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
-  delegated_frame_host_.reset(new DelegatedFrameHost(this));
+  browser_compositor_.reset(new BrowserCompositorMac(
+      this, this, render_widget_host_->is_hidden(), [cocoa_view_ window]));
 
   display::Screen::GetScreen()->AddObserver(this);
 
   if (!is_guest_view_hack_)
     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();
 
   // Ensure that the browser compositor is destroyed in a safe order.
-  ShutdownBrowserCompositor();
+  browser_compositor_->Destroy();
 
   // We are owned by RenderWidgetHostViewCocoa, so if we go away before the
   // RenderWidgetHost does we need to tell it not to hold a stale pointer to
   // us.
   if (render_widget_host_) {
     // If this is a RenderWidgetHostViewGuest's platform_view_, we're not the
     // RWH's view, the RenderWidgetHostViewGuest is. So don't reset the RWH's
     // view, the RenderWidgetHostViewGuest will do it.
     if (!is_guest_view_hack_)
       render_widget_host_->SetView(NULL);
   }
 }
 
 void RenderWidgetHostViewMac::SetDelegate(
     NSObject<RenderWidgetHostViewMacDelegate>* delegate) {
   [cocoa_view_ setResponderDelegate:delegate];
 }
 
 void RenderWidgetHostViewMac::SetAllowPauseForResizeOrRepaint(bool allow) {
   allow_pause_for_resize_or_repaint_ = allow;
 }
 
 cc::SurfaceId RenderWidgetHostViewMac::SurfaceIdForTesting() const {
-  return delegated_frame_host_->SurfaceIdForTesting();
+  return browser_compositor_->GetDelegatedFrameHost()->SurfaceIdForTesting();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
 
-void RenderWidgetHostViewMac::EnsureBrowserCompositorView() {
-  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);
-    browser_compositor_state_ = BrowserCompositorSuspended;
-  }
-
-  // Show the DelegatedFrameHost to transition from Suspended -> Active.
-  if (browser_compositor_state_ == BrowserCompositorSuspended) {
-    delegated_frame_host_->SetCompositor(browser_compositor_->compositor());
-    delegated_frame_host_->WasShown(ui::LatencyInfo());
-    // Unsuspend the browser compositor after showing the delegated frame host.
-    // If there is not a saved delegated frame, then the delegated frame host
-    // will keep the compositor locked until a delegated frame is swapped.
-    float scale_factor = ViewScaleFactor();
-    browser_compositor_->compositor()->SetScaleAndSize(
-        scale_factor,
-        gfx::ConvertSizeToPixel(scale_factor, GetViewBounds().size()));
-    browser_compositor_->Unsuspend();
-    browser_compositor_state_ = BrowserCompositorActive;
-  }
-}
-
-void RenderWidgetHostViewMac::SuspendBrowserCompositorView() {
-  TRACE_EVENT0("browser",
-               "RenderWidgetHostViewMac::SuspendBrowserCompositorView");
-
-  // Hide the DelegatedFrameHost to transition from Active -> Suspended.
-  if (browser_compositor_state_ == BrowserCompositorActive) {
-    // Ensure that any changes made to the ui::Compositor do not result in new
-    // frames being produced.
-    browser_compositor_->Suspend();
-    // Marking the DelegatedFrameHost as removed from the window hierarchy is
-    // necessary to remove all connections to its old ui::Compositor.
-    delegated_frame_host_->WasHidden();
-    delegated_frame_host_->ResetCompositor();
-    browser_compositor_state_ = BrowserCompositorSuspended;
-  }
-}
-
-void RenderWidgetHostViewMac::DestroyBrowserCompositorView() {
-  TRACE_EVENT0("browser",
-               "RenderWidgetHostViewMac::DestroyBrowserCompositorView");
-
-  // Transition from Active -> Suspended if need be.
-  SuspendBrowserCompositorView();
-
-  // Destroy the BrowserCompositorView to transition Suspended -> Destroyed.
-  if (browser_compositor_state_ == BrowserCompositorSuspended) {
-    browser_compositor_->accelerated_widget_mac()->ResetNSView();
-    browser_compositor_->compositor()->SetScaleAndSize(1.0, gfx::Size(0, 0));
-    browser_compositor_->compositor()->SetRootLayer(nullptr);
-    BrowserCompositorMac::Recycle(std::move(browser_compositor_));
-    browser_compositor_state_ = BrowserCompositorDestroyed;
-  }
-}
-
-void RenderWidgetHostViewMac::DestroySuspendedBrowserCompositorViewIfNeeded() {
-  if (browser_compositor_state_ != BrowserCompositorSuspended)
-    return;
-
-  // 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.
-  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)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 125 matching lines @@
 void RenderWidgetHostViewMac::SendVSyncParametersToRenderer() {
   if (!render_widget_host_ || !display_link_.get())
     return;
 
   if (!display_link_->GetVSyncParameters(&vsync_timebase_, &vsync_interval_)) {
     vsync_timebase_ = base::TimeTicks();
     vsync_interval_ = base::TimeDelta();
     return;
   }
 
-  if (browser_compositor_) {
-    browser_compositor_->compositor()->vsync_manager()->UpdateVSyncParameters(
-        vsync_timebase_, vsync_interval_);
-  }
+  browser_compositor_->UpdateVSyncParameters(vsync_timebase_, vsync_interval_);
 }
 
 void RenderWidgetHostViewMac::SpeakText(const std::string& text) {
   [NSApp speakString:base::SysUTF8ToNSString(text)];
 }
 
 void RenderWidgetHostViewMac::UpdateBackingStoreProperties() {
   if (!render_widget_host_)
     return;
   render_widget_host_->NotifyScreenInfoChanged();
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::Show() {
   ScopedCAActionDisabler disabler;
   [cocoa_view_ setHidden:NO];
 
-  // 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();
+  browser_compositor_->SetRenderWidgetHostIsHidden(false);
 
-  if (!render_widget_host_->is_hidden())
-    return;
-
-  WasUnOccluded();
+  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);
 
   // 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();
-    SuspendBrowserCompositorView();
-  }
-  DestroySuspendedBrowserCompositorViewIfNeeded();
+
+  render_widget_host_->WasHidden();
+  browser_compositor_->SetRenderWidgetHostIsHidden(true);
 }
 
 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);
+  browser_compositor_->SetRenderWidgetHostIsHidden(false);
+  render_widget_host_->WasShown(ui::LatencyInfo());
 }
 
 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()
-            ->MightBeInFullscreenLowPowerMode())
-      return;
+  ui::AcceleratedWidgetMac* accelerated_widget_mac =
+      browser_compositor_->GetAcceleratedWidgetMac();
+  if (accelerated_widget_mac &&
+      accelerated_widget_mac->MightBeInFullscreenLowPowerMode()) {
+    return;
   }
 
-  // Note the importance of ordering of these calls is the same in the Hide
-  // function.
   render_widget_host_->WasHidden();
-  SuspendBrowserCompositorView();
+  browser_compositor_->SetRenderWidgetHostIsHidden(true);
 }
 
 void RenderWidgetHostViewMac::SetSize(const gfx::Size& size) {
   gfx::Rect rect = GetViewBounds();
   rect.set_size(size);
   SetBounds(rect);
 }
 
 void RenderWidgetHostViewMac::SetBounds(const gfx::Rect& rect) {
   // |rect.size()| is view coordinates, |rect.origin| is screen coordinates,
@@ skipping 57 matching lines @@
 
 void RenderWidgetHostViewMac::Focus() {
   [[cocoa_view_ window] makeFirstResponder:cocoa_view_];
 }
 
 bool RenderWidgetHostViewMac::HasFocus() const {
   return [[cocoa_view_ window] firstResponder] == cocoa_view_;
 }
 
 bool RenderWidgetHostViewMac::IsSurfaceAvailableForCopy() const {
-  DCHECK(delegated_frame_host_);
-  return delegated_frame_host_->CanCopyToBitmap();
+  return browser_compositor_->GetDelegatedFrameHost()->CanCopyToBitmap();
 }
 
 bool RenderWidgetHostViewMac::IsShowing() {
   return ![cocoa_view_ isHidden];
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetViewBounds() const {
   NSRect bounds = [cocoa_view_ bounds];
   // TODO(shess): In case of !window, the view has been removed from
   // the view hierarchy because the tab isn't main.  Could retrieve
@@ skipping 78 matching lines @@
   fullscreen_window_manager_.reset();
   [pepper_fullscreen_window_ close];
 
   // This can be called as part of processing the window's responder
   // chain, for instance |-performKeyEquivalent:|.  In that case the
   // object needs to survive until the stack unwinds.
   pepper_fullscreen_window_.autorelease();
 
   // Delete the delegated frame state, which will reach back into
   // render_widget_host_.
-  ShutdownBrowserCompositor();
+  browser_compositor_->Destroy();
 
   // Make sure none of our observers send events for us to process after
   // we release render_widget_host_.
   NotifyObserversAboutShutdown();
 
   // We get this call just before |render_widget_host_| deletes
   // itself.  But we are owned by |cocoa_view_|, which may be retained
   // by some other code.  Examples are WebContentsViewMac's
   // |latent_focus_view_| and TabWindowController's
   // |cachedContentView_|.
@@ skipping 120 matching lines @@
 
 bool RenderWidgetHostViewMac::IsPopup() const {
   return popup_type_ != blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const ReadbackRequestCallback& callback,
     const SkColorType preferred_color_type) {
-  DCHECK(delegated_frame_host_);
-  delegated_frame_host_->CopyFromCompositingSurface(
+  browser_compositor_->CopyFromCompositingSurface(
       src_subrect, dst_size, callback, preferred_color_type);
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
-  DCHECK(delegated_frame_host_);
-  delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
-      src_subrect, target, callback);
+  browser_compositor_->CopyFromCompositingSurfaceToVideoFrame(src_subrect,
+                                                              target, callback);
 }
 
 bool RenderWidgetHostViewMac::CanCopyToVideoFrame() const {
-  DCHECK(delegated_frame_host_);
-  return delegated_frame_host_->CanCopyToVideoFrame();
+  return browser_compositor_->GetDelegatedFrameHost()->CanCopyToVideoFrame();
 }
 
 void RenderWidgetHostViewMac::BeginFrameSubscription(
     std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
-  DCHECK(delegated_frame_host_);
-  delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
+  browser_compositor_->GetDelegatedFrameHost()->BeginFrameSubscription(
+      std::move(subscriber));
 }
 
 void RenderWidgetHostViewMac::EndFrameSubscription() {
-  DCHECK(delegated_frame_host_);
-  delegated_frame_host_->EndFrameSubscription();
+  browser_compositor_->GetDelegatedFrameHost()->EndFrameSubscription();
 }
 
 ui::AcceleratedWidgetMac* RenderWidgetHostViewMac::GetAcceleratedWidgetMac()
     const {
-  if (browser_compositor_)
-    return browser_compositor_->accelerated_widget_mac();
-  return nullptr;
+  return browser_compositor_->GetAcceleratedWidgetMac();
 }
 
 void RenderWidgetHostViewMac::ForwardMouseEvent(const WebMouseEvent& event) {
   if (render_widget_host_)
     render_widget_host_->ForwardMouseEvent(event);
 
   if (event.type == WebInputEvent::MouseLeave) {
     [cocoa_view_ setToolTipAtMousePoint:nil];
     tooltip_text_.clear();
   }
@@ skipping 144 matching lines @@
   if (actual_range) {
     *actual_range = gfx::Range(
         composition_range_.start() + ui_actual_range.start(),
         composition_range_.start() + ui_actual_range.end()).ToNSRange();
   }
   return true;
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
-  if (browser_compositor_) {
-    return browser_compositor_->accelerated_widget_mac()->HasFrameOfSize(
-        desired_size);
-  }
+  ui::AcceleratedWidgetMac* accelerated_widget_mac =
+      browser_compositor_->GetAcceleratedWidgetMac();
+  if (accelerated_widget_mac)
+    return accelerated_widget_mac->HasFrameOfSize(desired_size);
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(uint32_t output_surface_id,
                                                     cc::CompositorFrame frame) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::OnSwapCompositorFrame");
 
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
 
   page_at_minimum_scale_ =
       frame.metadata.page_scale_factor == frame.metadata.min_page_scale_factor;
-
   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();
-      browser_compositor_->compositor()->SetScaleAndSize(
-          scale_factor, pixel_size);
-    }
-
+    // TODO(ccameron): This would not be needed if BrowserCompostiorMac were to
+    // correctly subscribe to the show and hide notifications for
+    // RenderWidgetHostImpl. We do not correctly subscribe to these
+    // notifications because we want to set the hide property property only
+    // after all notifications (the thumbnailer in particular) have all
+    // completed.
+    browser_compositor_->SetRenderWidgetHostIsHidden(
+        render_widget_host_->is_hidden());
+    browser_compositor_->SwapCompositorFrame(output_surface_id,
+                                             std::move(frame));
     SendVSyncParametersToRenderer();
-
-    delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
-                                              std::move(frame));
   } else {
     DLOG(ERROR) << "Received unexpected frame type.";
     bad_message::ReceivedBadMessage(render_widget_host_->GetProcess(),
                                     bad_message::RWHVM_UNEXPECTED_FRAME_TYPE);
   }
 }
 
 void RenderWidgetHostViewMac::ClearCompositorFrame() {
-  delegated_frame_host_->ClearDelegatedFrame();
+  browser_compositor_->GetDelegatedFrameHost()->ClearDelegatedFrame();
 }
 
 void RenderWidgetHostViewMac::GetScreenInfo(blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(GetNativeView());
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetBoundsInRootWindow() {
   // TODO(shess): In case of !window, the view has been removed from
   // the view hierarchy because the tab isn't main.  Could retrieve
   // the information from the main tab for our window.
@@ skipping 59 matching lines @@
 
 std::unique_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewMac::CreateSyntheticGestureTarget() {
   RenderWidgetHostImpl* host =
       RenderWidgetHostImpl::From(GetRenderWidgetHost());
   return std::unique_ptr<SyntheticGestureTarget>(
       new SyntheticGestureTargetMac(host, cocoa_view_));
 }
 
 uint32_t RenderWidgetHostViewMac::GetSurfaceIdNamespace() {
-  DCHECK(delegated_frame_host_);
-  return delegated_frame_host_->GetSurfaceIdNamespace();
+  return browser_compositor_->GetDelegatedFrameHost()->GetSurfaceIdNamespace();
 }
 
 uint32_t RenderWidgetHostViewMac::SurfaceIdNamespaceAtPoint(
     cc::SurfaceHittestDelegate* delegate,
     const gfx::Point& point,
     gfx::Point* transformed_point) {
   // The surface hittest happens in device pixels, so we need to convert the
   // |point| from DIPs to pixels before hittesting.
   float scale_factor = display::Screen::GetScreen()
                            ->GetDisplayNearestWindow(cocoa_view_)
                            .device_scale_factor();
   gfx::Point point_in_pixels = gfx::ConvertPointToPixel(scale_factor, point);
-  cc::SurfaceId id = delegated_frame_host_->SurfaceIdAtPoint(
-      delegate, point_in_pixels, transformed_point);
+  cc::SurfaceId id =
+      browser_compositor_->GetDelegatedFrameHost()->SurfaceIdAtPoint(
+          delegate, point_in_pixels, transformed_point);
   *transformed_point = gfx::ConvertPointToDIP(scale_factor, *transformed_point);
 
   // It is possible that the renderer has not yet produced a surface, in which
   // case we return our current namespace.
   if (id.is_null())
     return GetSurfaceIdNamespace();
   return id.id_namespace();
 }
 
 bool RenderWidgetHostViewMac::ShouldRouteEvent(
@@ skipping 34 matching lines @@
 void RenderWidgetHostViewMac::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     cc::SurfaceId original_surface,
     gfx::Point* transformed_point) {
   // Transformations use physical pixels rather than DIP, so conversion
   // is necessary.
   float scale_factor = display::Screen::GetScreen()
                            ->GetDisplayNearestWindow(cocoa_view_)
                            .device_scale_factor();
   gfx::Point point_in_pixels = gfx::ConvertPointToPixel(scale_factor, point);
-  delegated_frame_host_->TransformPointToLocalCoordSpace(
+  browser_compositor_->GetDelegatedFrameHost()->TransformPointToLocalCoordSpace(
       point_in_pixels, original_surface, transformed_point);
   *transformed_point = gfx::ConvertPointToDIP(scale_factor, *transformed_point);
 }
 
 bool RenderWidgetHostViewMac::Send(IPC::Message* message) {
   if (render_widget_host_)
     return render_widget_host_->Send(message);
   delete message;
   return false;
 }
 
 void RenderWidgetHostViewMac::ShutdownHost() {
   weak_factory_.InvalidateWeakPtrs();
   render_widget_host_->ShutdownAndDestroyWidget(true);
   // Do not touch any members at this point, |this| has been deleted.
 }
 
-void RenderWidgetHostViewMac::ShutdownBrowserCompositor() {
-  DestroyBrowserCompositorView();
-  delegated_frame_host_.reset();
-  root_layer_.reset();
-  browser_compositor_placeholder_.reset();
-}
-
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_) {
     render_widget_host_->SetActive(active);
     if (active) {
       if (HasFocus())
         render_widget_host_->Focus();
     } else {
       render_widget_host_->Blur();
     }
   }
@@ skipping 12 matching lines @@
   if (color == background_color_)
     return;
 
   RenderWidgetHostViewBase::SetBackgroundColor(color);
   bool opaque = GetBackgroundOpaque();
 
   if (render_widget_host_)
     render_widget_host_->SetBackgroundOpaque(opaque);
 
   [cocoa_view_ setOpaque:opaque];
-  if (browser_compositor_state_ != BrowserCompositorDestroyed)
-    browser_compositor_->compositor()->SetHostHasTransparentBackground(!opaque);
+
+  browser_compositor_->SetHasTransparentBackground(!opaque);
 
   ScopedCAActionDisabler disabler;
   base::ScopedCFTypeRef<CGColorRef> cg_color(
       skia::CGColorCreateFromSkColor(color));
   [background_layer_ setBackgroundColor:cg_color];
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostViewMac::CreateBrowserAccessibilityManager(
         BrowserAccessibilityDelegate* delegate, bool for_root_frame) {
@@ skipping 934 matching lines @@
   [super setFrameSize:newSize];
 
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
   if (renderWidgetHostView_->render_widget_host_->delegate())
     renderWidgetHostView_->render_widget_host_->delegate()->SendScreenRects();
   else
     renderWidgetHostView_->render_widget_host_->SendScreenRects();
   renderWidgetHostView_->render_widget_host_->WasResized();
-  if (renderWidgetHostView_->delegated_frame_host_)
-    renderWidgetHostView_->delegated_frame_host_->WasResized();
+  renderWidgetHostView_->browser_compositor_->GetDelegatedFrameHost()
+      ->WasResized();
 
   // Wait for the frame that WasResize might have requested. If the view is
   // being made visible at a new size, then this call will have no effect
   // because the view widget is still hidden, and the pause call in WasShown
   // will have this effect for us.
   renderWidgetHostView_->PauseForPendingResizeOrRepaintsAndDraw();
 }
 
 - (BOOL)canBecomeKeyView {
   if (!renderWidgetHostView_->render_widget_host_)
@@ skipping 549 matching lines @@
   hasMarkedText_ = NO;
 }
 
 - (void)insertText:(id)string {
   [self insertText:string replacementRange:NSMakeRange(NSNotFound, 0)];
 }
 
 - (void)viewDidMoveToWindow {
   if ([self window]) {
     [self updateScreenProperties];
-  } else {
-    // If the RenderWidgetHostViewCocoa is being removed from its window, tear
-    // down its browser compositor resources, if needed.
-    renderWidgetHostView_->DestroySuspendedBrowserCompositorViewIfNeeded();
   }
+  renderWidgetHostView_->browser_compositor_->SetNSViewAttachedToWindow(
+      [self window]);
 
   // If we switch windows (or are removed from the view hierarchy), cancel any
   // open mouse-downs.
   if (hasOpenMouseDown_) {
     WebMouseEvent event;
     event.type = WebInputEvent::MouseUp;
     event.button = WebMouseEvent::ButtonLeft;
     renderWidgetHostView_->ForwardMouseEvent(event);
 
     hasOpenMouseDown_ = NO;
@@ skipping 171 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