Prepare to move BrowserCompositorViewMac to ui

content/browser/compositor/browser_compositor_ca_layer_tree_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/compositor/browser_compositor_ca_layer_tree_mac.h"
 
 #include <map>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
@@ skipping 14 matching lines @@
 typedef std::map<gfx::AcceleratedWidget,BrowserCompositorCALayerTreeMac*>
     WidgetToInternalsMap;
 base::LazyInstance<WidgetToInternalsMap> g_widget_to_internals_map;
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserCompositorCALayerTreeMac
 
 BrowserCompositorCALayerTreeMac::BrowserCompositorCALayerTreeMac()
-    : client_(NULL),
+    : view_(NULL),
       accelerated_output_surface_id_(0) {
   // Disable the fade-in animation as the layers are added.
   ScopedCAActionDisabler disabler;
 
   // Add a flipped transparent layer as a child, so that we don't need to
   // fiddle with the position of sub-layers -- they will always be at the
   // origin.
   flipped_layer_.reset([[CALayer alloc] init]);
   [flipped_layer_ setGeometryFlipped:YES];
   [flipped_layer_ setAnchorPoint:CGPointMake(0, 0)];
@@ skipping 11 matching lines @@
 
   // Create a compositor to draw the contents of this view.
   compositor_.reset(new ui::Compositor(
       native_widget_,
       content::GetContextFactory(),
       RenderWidgetResizeHelper::Get()->task_runner()));
   compositor_->SetVisible(false);
 }
 
 BrowserCompositorCALayerTreeMac::~BrowserCompositorCALayerTreeMac() {
-  DCHECK(!client_);
+  DCHECK(!view_);
   g_widget_to_internals_map.Pointer()->erase(native_widget_);
 }
 
-void BrowserCompositorCALayerTreeMac::SetClient(
-    BrowserCompositorViewMacClient* client) {
+void BrowserCompositorCALayerTreeMac::SetView(
+    BrowserCompositorViewMac* view) {
   // Disable the fade-in animation as the view is added.
   ScopedCAActionDisabler disabler;
 
-  DCHECK(client && !client_);
-  client_ = client;
-  compositor_->SetRootLayer(client_->BrowserCompositorRootLayer());
+  DCHECK(view && !view_);
+  view_ = view;
+  compositor_->SetRootLayer(view_->ui_root_layer());
 
-  CALayer* background_layer = [client_->BrowserCompositorSuperview() layer];
+  CALayer* background_layer = [view_->native_view() layer];
   DCHECK(background_layer);
   [flipped_layer_ setBounds:[background_layer bounds]];
   [background_layer addSublayer:flipped_layer_];
   compositor_->SetVisible(true);
 }
 
-void BrowserCompositorCALayerTreeMac::ResetClient() {
-  if (!client_)
+void BrowserCompositorCALayerTreeMac::ResetView() {
+  if (!view_)
     return;
 
   // Disable the fade-out animation as the view is removed.
   ScopedCAActionDisabler disabler;
 
   [flipped_layer_ removeFromSuperlayer];
   DestroyIOSurfaceLayer(io_surface_layer_);
   DestroyCAContextLayer(ca_context_layer_);
   DestroySoftwareLayer();
 
   accelerated_output_surface_id_ = 0;
   last_swap_size_dip_ = gfx::Size();
 
   compositor_->SetVisible(false);
   compositor_->SetScaleAndSize(1.0, gfx::Size(0, 0));
   compositor_->SetRootLayer(NULL);
-  client_ = NULL;
+  view_ = NULL;
 }
 
 bool BrowserCompositorCALayerTreeMac::HasFrameOfSize(
     const gfx::Size& dip_size) const {
   return last_swap_size_dip_ == dip_size;
 }
 
 int BrowserCompositorCALayerTreeMac::GetRendererID() const {
   if (io_surface_layer_)
     return [io_surface_layer_ rendererID];
   return 0;
 }
 
 bool BrowserCompositorCALayerTreeMac::IsRendererThrottlingDisabled() const {
-  if (client_)
-    return client_->BrowserCompositorViewShouldAckImmediately();
+  if (view_)
+    return view_->client()->BrowserCompositorViewShouldAckImmediately();
   return false;
 }
 
 void BrowserCompositorCALayerTreeMac::BeginPumpingFrames() {
   [io_surface_layer_ beginPumpingFrames];
 }
 
 void BrowserCompositorCALayerTreeMac::EndPumpingFrames() {
   [io_surface_layer_ endPumpingFrames];
 }
 
 void BrowserCompositorCALayerTreeMac::GotAcceleratedFrame(
     uint64 surface_handle, int output_surface_id,
     const std::vector<ui::LatencyInfo>& latency_info,
     gfx::Size pixel_size, float scale_factor) {
   // Record the surface and latency info to use when acknowledging this frame.
   DCHECK(!accelerated_output_surface_id_);
   accelerated_output_surface_id_ = output_surface_id;
   accelerated_latency_info_.insert(accelerated_latency_info_.end(),
                                    latency_info.begin(), latency_info.end());
 
-  // If there is no client and therefore no superview to draw into, early-out.
-  if (!client_) {
+  // If there is no view and therefore no superview to draw into, early-out.
+  if (!view_) {
     IOSurfaceLayerDidDrawFrame();
     return;
   }
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
   last_swap_size_dip_ = ConvertSizeToDIP(scale_factor, pixel_size);
   switch (GetSurfaceHandleType(surface_handle)) {
     case kSurfaceHandleTypeIOSurface: {
@@ skipping 112 matching lines @@
 
   // Remove any different-type layers that this is replacing.
   DestroyCAContextLayer(ca_context_layer_);
   DestroySoftwareLayer();
 }
 
 void BrowserCompositorCALayerTreeMac::GotSoftwareFrame(
     cc::SoftwareFrameData* frame_data,
     float scale_factor,
     SkCanvas* canvas) {
-  if (!frame_data || !canvas || !client_)
+  if (!frame_data || !canvas || !view_)
     return;
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
   // If there is not a layer for software frames, create one.
   if (!software_layer_) {
     software_layer_.reset([[SoftwareLayer alloc] init]);
     [flipped_layer_ addSublayer:software_layer_];
   }
@@ skipping 35 matching lines @@
 
 void BrowserCompositorCALayerTreeMac::DestroySoftwareLayer() {
   if (!software_layer_)
     return;
   [software_layer_ removeFromSuperlayer];
   software_layer_.reset();
 }
 
 bool BrowserCompositorCALayerTreeMac::IOSurfaceLayerShouldAckImmediately()
     const {
-  // If there is no client then the accelerated layer is not in the hierarchy
+  // If there is no view then the accelerated layer is not in the hierarchy
   // and will never draw.
-  if (!client_)
+  if (!view_)
     return true;
-  return client_->BrowserCompositorViewShouldAckImmediately();
+  return view_->client()->BrowserCompositorViewShouldAckImmediately();
 }
 
 void BrowserCompositorCALayerTreeMac::IOSurfaceLayerDidDrawFrame() {
   if (accelerated_output_surface_id_) {
     content::ImageTransportFactory::GetInstance()->OnSurfaceDisplayed(
         accelerated_output_surface_id_);
     accelerated_output_surface_id_ = 0;
   }
 
-  if (client_)
-    client_->BrowserCompositorViewFrameSwapped(accelerated_latency_info_);
+  if (view_) {
+    view_->client()->BrowserCompositorViewFrameSwapped(
+        accelerated_latency_info_);
+  }
 
   accelerated_latency_info_.clear();
 }
 
 void BrowserCompositorCALayerTreeMac::IOSurfaceLayerHitError() {
   // Perform all acks that would have been done if the frame had succeeded, to
   // un-block the compositor and renderer.
   IOSurfaceLayerDidDrawFrame();
 
   // Poison the context being used and request a mulligan.
   [io_surface_layer_ poisonContextAndSharegroup];
   compositor_->ScheduleFullRedraw();
 }
 
 // static
 BrowserCompositorCALayerTreeMac* BrowserCompositorCALayerTreeMac::
     FromAcceleratedWidget(gfx::AcceleratedWidget widget) {
   WidgetToInternalsMap::const_iterator found =
       g_widget_to_internals_map.Pointer()->find(widget);
   // This can end up being accessed after the underlying widget has been
   // destroyed, but while the ui::Compositor is still being destroyed.
   // Return NULL in these cases.
   if (found == g_widget_to_internals_map.Pointer()->end())
     return NULL;
   return found->second;
 }
 
+void BrowserCompositorCALayerTreeMacGotAcceleratedFrame(
+    gfx::AcceleratedWidget widget,
+    uint64 surface_handle, int surface_id,
+    const std::vector<ui::LatencyInfo>& latency_info,
+    gfx::Size pixel_size, float scale_factor,
+    bool* disable_throttling, int* renderer_id) {
+  BrowserCompositorCALayerTreeMac* ca_layer_tree =
+      BrowserCompositorCALayerTreeMac::FromAcceleratedWidget(widget);
+  if (ca_layer_tree) {
+    ca_layer_tree->GotAcceleratedFrame(
+        surface_handle, surface_id, latency_info, pixel_size, scale_factor);
+    *disable_throttling = ca_layer_tree->IsRendererThrottlingDisabled();
+    *renderer_id = ca_layer_tree->GetRendererID();
+  } else {
+    *disable_throttling = false;
+    *renderer_id = 0;
+  }
+}
+
+void BrowserCompositorCALayerTreeMacGotSoftwareFrame(
+    gfx::AcceleratedWidget widget,
+    cc::SoftwareFrameData* frame_data, float scale_factor, SkCanvas* canvas) {
+  BrowserCompositorCALayerTreeMac* ca_layer_tree =
+      BrowserCompositorCALayerTreeMac::FromAcceleratedWidget(widget);
+  if (ca_layer_tree)
+    ca_layer_tree->GotSoftwareFrame(frame_data, scale_factor, canvas);
+}
+
 }  // namespace content