Create an AcceleratedWidgetMac

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>
 
@@ skipping 377 matching lines @@
 }
 
 }  // namespace
 
 namespace content {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Compositor* RenderWidgetHostViewMac::GetCompositor() const {
-  // When |browser_compositor_view_| is suspended or destroyed, the connection
+  // When |browser_compositor_| is suspended or destroyed, the connection
   // between its ui::Compositor and |delegated_frame_host_| has been severed.
   if (browser_compositor_state_ == BrowserCompositorActive)
-    return browser_compositor_view_->GetCompositor();
+    return browser_compositor_->compositor();
   return NULL;
 }
 
 ui::Layer* RenderWidgetHostViewMac::GetLayer() {
   return root_layer_.get();
 }
 
 RenderWidgetHostImpl* RenderWidgetHostViewMac::GetHost() {
   return render_widget_host_;
 }
@@ skipping 21 matching lines @@
   NOTREACHED();
   ResizeLock* lock = NULL;
   return scoped_ptr<ResizeLock>(lock);
 }
 
 DelegatedFrameHost* RenderWidgetHostViewMac::GetDelegatedFrameHost() const {
   return delegated_frame_host_.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// BrowserCompositorViewMacClient, public:
+// AcceleratedWidgetMacNSView, public:
 
-bool RenderWidgetHostViewMac::BrowserCompositorViewShouldAckImmediately()
+NSView* RenderWidgetHostViewMac::AcceleratedWidgetGetNSView() const {
+  return cocoa_view_;
+}
+
+bool RenderWidgetHostViewMac::AcceleratedWidgetShouldIgnoreBackpressure()
     const {
   // If vsync is disabled, then always draw and ack frames immediately.
   static bool is_vsync_disabled =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuVsync);
   if (is_vsync_disabled)
     return true;
 
   // If the window is occluded, then this frame's display call may be severely
   // throttled. This is a good thing, unless tab capture may be active, because
@@ skipping 21 matching lines @@
       // immediately.
       return true;
     }
   }
 
   // If the window occlusion API is not present then ack frames when we draw
   // them.
   return false;
 }
 
-void RenderWidgetHostViewMac::BrowserCompositorViewFrameSwapped(
+void RenderWidgetHostViewMac::AcceleratedWidgetSwapCompleted(
     const std::vector<ui::LatencyInfo>& all_latency_info) {
   if (!render_widget_host_)
     return;
   for (auto latency_info : all_latency_info) {
     latency_info.AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
     render_widget_host_->FrameSwapped(latency_info);
   }
 }
 
+void RenderWidgetHostViewMac::AcceleratedWidgetHitError() {
+  // Request a new frame be drawn.
+  browser_compositor_->compositor()->ScheduleFullRedraw();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
     blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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_view_placeholder_(
-          new BrowserCompositorViewPlaceholderMac),
+      browser_compositor_placeholder_(
+          new BrowserCompositorMacPlaceholder),

[tapted, 2014/11/20 05:38:54]

nit: pull up?

[ccameron, 2014/11/20 21:33:51]

Done.

       is_loading_(false),
       allow_pause_for_resize_or_repaint_(true),
       is_guest_view_hack_(is_guest_view_hack),
       weak_factory_(this),
       fullscreen_parent_host_view_(NULL) {
   // |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];
@@ skipping 53 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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_view_.reset(
-        new BrowserCompositorViewMac(this, cocoa_view_, root_layer_.get()));
+    BrowserCompositorMac::AcquireCompositor(&browser_compositor_);
+    browser_compositor_->compositor()->SetRootLayer(
+        root_layer_.get());
+    browser_compositor_->accelerated_widget_mac()->SetClient(this);
+    browser_compositor_->compositor()->SetVisible(true);
     browser_compositor_state_ = BrowserCompositorSuspended;
   }
 
   // Show the DelegatedFrameHost to transition from Suspended -> Active.
   if (browser_compositor_state_ == BrowserCompositorSuspended) {
     delegated_frame_host_->AddedToWindow();
     delegated_frame_host_->WasShown(ui::LatencyInfo());
     browser_compositor_state_ = BrowserCompositorActive;
   }
 }
@@ skipping 14 matching lines @@
 
 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_view_.reset();
+    browser_compositor_->accelerated_widget_mac()->ResetClient();
+    browser_compositor_->compositor()->SetVisible(false);
+    browser_compositor_->compositor()->SetScaleAndSize(1.0, gfx::Size(0, 0));
+    browser_compositor_->compositor()->SetRootLayer(NULL);
+    BrowserCompositorMac::ReleaseCompositor(&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
@@ skipping 755 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_view_)
-    return browser_compositor_view_->HasFrameOfSize(desired_size);
+  if (browser_compositor_) {
+    return browser_compositor_->accelerated_widget_mac()->HasFrameOfSize(
+        desired_size);
+  }
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(
     uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::OnSwapCompositorFrame");
 
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
   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();
     gfx::Size pixel_size = root_pass->output_rect.size();
     gfx::Size dip_size =
         ConvertSizeToDIP(scale_factor, pixel_size);
 
     root_layer_->SetBounds(gfx::Rect(dip_size));
     if (!render_widget_host_->is_hidden()) {
       EnsureBrowserCompositorView();
-      browser_compositor_view_->GetCompositor()->SetScaleAndSize(
+      browser_compositor_->compositor()->SetScaleAndSize(
           scale_factor, pixel_size);
     }
 
     SendVSyncParametersToRenderer();
 
     delegated_frame_host_->SwapDelegatedFrame(
         output_surface_id,
         frame->delegated_frame_data.Pass(),
         frame->metadata.device_scale_factor,
         frame->metadata.latency_info);
@@ skipping 76 matching lines @@
 void RenderWidgetHostViewMac::ShutdownHost() {
   weak_factory_.InvalidateWeakPtrs();
   render_widget_host_->Shutdown();
   // 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_view_placeholder_.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 105 matching lines @@
 void RenderWidgetHostViewMac::PauseForPendingResizeOrRepaintsAndDraw() {
   if (!render_widget_host_ || render_widget_host_->is_hidden())
     return;
 
   // Pausing for one view prevents others from receiving frames.
   // This may lead to large delays, causing overlaps. See crbug.com/352020.
   if (!allow_pause_for_resize_or_repaint_)
     return;
 
   // Wait for a frame of the right size to come in.
-  if (browser_compositor_view_)
-    browser_compositor_view_->BeginPumpingFrames();
+  if (browser_compositor_)
+    browser_compositor_->accelerated_widget_mac()->BeginPumpingFrames();
   render_widget_host_->PauseForPendingResizeOrRepaints();
-  if (browser_compositor_view_)
-    browser_compositor_view_->EndPumpingFrames();
+  if (browser_compositor_)
+    browser_compositor_->accelerated_widget_mac()->EndPumpingFrames();
 }
 
 SkColorType RenderWidgetHostViewMac::PreferredReadbackFormat() {
   return kN32_SkColorType;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // gfx::DisplayObserver, public:
 
 void RenderWidgetHostViewMac::OnDisplayAdded(const gfx::Display& display) {
@@ skipping 1690 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