Prepare to move BrowserCompositorViewMac to ui

content/browser/compositor/browser_compositor_view_mac.h

 // 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.
 
 #ifndef CONTENT_BROWSER_COMPOSITOR_BROWSER_COMPOSITOR_VIEW_MAC_H_
 #define CONTENT_BROWSER_COMPOSITOR_BROWSER_COMPOSITOR_VIEW_MAC_H_
 
+#include <Cocoa/Cocoa.h>

[tapted, 2014/10/17 00:04:35]

ui/gfx/native_widget_types.h (and NSView -> gfx::NativeView) might be an option
if we want to avoid ObjC creeping in here. However, I'm pretty sure the current
client code is all .mm.

[ccameron, 2014/10/17 00:26:53]

Actually, the #include turned out not the be necessary at all -- removed.

 #include <vector>
 
 #include "cc/output/software_frame_data.h"
 #include "skia/ext/platform_canvas.h"
 #include "ui/compositor/compositor.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 class BrowserCompositorCALayerTreeMac;
 
 // The interface through which BrowserCompositorViewMac calls back into
 // RenderWidgetHostViewMac (or any other structure that wishes to draw a
 // NSView backed by a ui::Compositor).
+// TODO(ccameron): This interface should be in the ui namespace.
 class BrowserCompositorViewMacClient {
  public:
   // Drawing is usually throttled by the rate at which CoreAnimation draws
   // frames to the screen. This can be used to disable throttling.
   virtual bool BrowserCompositorViewShouldAckImmediately() const = 0;
 
   // Called when a frame is drawn, and used to pass latency info back to the
   // renderer (if any).
   virtual void BrowserCompositorViewFrameSwapped(
       const std::vector<ui::LatencyInfo>& latency_info) = 0;
-
-  // Used to install the ui::Compositor-backed NSView as a child of its parent
-  // view.
-  virtual NSView* BrowserCompositorSuperview() = 0;
-
-  // Used to install the root ui::Layer into the ui::Compositor.
-  virtual ui::Layer* BrowserCompositorRootLayer() = 0;
 };
 
 // The class to hold a ui::Compositor-backed NSView. Because a ui::Compositor
 // is expensive in terms of resources and re-allocating a ui::Compositor is
 // expensive in terms of work, this class is largely used to manage recycled
 // instances of BrowserCompositorViewCocoa, which actually is a NSView and
 // has a ui::Compositor instance.
+// TODO(ccameron): This should implement an interface in the ui namespace.

[danakj, 2014/10/16 23:38:56]

Can you mark which methods would be that interface? 

[ccameron, 2014/10/17 00:02:19]

Done.

 class BrowserCompositorViewMac {
  public:
   // This will install the NSView which is drawn by the ui::Compositor into
   // the NSView provided by the client.
-  explicit BrowserCompositorViewMac(BrowserCompositorViewMacClient* client);
+  explicit BrowserCompositorViewMac(

[tapted, 2014/10/17 00:04:36]

nit: explicit not needed

[ccameron, 2014/10/17 00:26:53]

Done.

+      BrowserCompositorViewMacClient* client,
+      NSView* native_view,
+      ui::Layer* ui_root_layer);
   ~BrowserCompositorViewMac();
 
+  BrowserCompositorViewMacClient* client() const { return client_; }
+  NSView* native_view() const { return native_view_; }
+  ui::Layer* ui_root_layer() const { return ui_root_layer_; }
+
   // The ui::Compositor being used to render the NSView.
   ui::Compositor* GetCompositor() const;
 
-  // The client (used by the BrowserCompositorViewCocoa to access the client).
-  BrowserCompositorViewMacClient* GetClient() const { return client_; }
-
   // Return true if the last frame swapped has a size in DIP of |dip_size|.
   bool HasFrameOfSize(const gfx::Size& dip_size) const;
 
   // Mark a bracket in which new frames are pumped in a restricted nested run
   // loop because the the target window is resizing or because the view is being
   // shown after previously being hidden.
   void BeginPumpingFrames();
   void EndPumpingFrames();
 
-  static void GotAcceleratedFrame(
-      gfx::AcceleratedWidget widget,
-      uint64 surface_handle, int surface_id,
-      const std::vector<ui::LatencyInfo>& latency_info,
-      gfx::Size pixel_size, float scale_factor,
-      int gpu_host_id, int gpu_route_id);
-
-  static void GotSoftwareFrame(
-      gfx::AcceleratedWidget widget,
-      cc::SoftwareFrameData* frame_data, float scale_factor, SkCanvas* canvas);
-
  private:
   BrowserCompositorViewMacClient* client_;
+  NSView* native_view_;

[tapted, 2014/10/17 00:04:36]

Thinking if there might be any lifetime issue around these... Perhaps comment in
the constructor like "|client| should own both the BrowserCompositorViewMac(..)
and |native_view|.

[ccameron, 2014/10/17 00:26:53]

Done -- added a comment to the ctor.

+  ui::Layer* ui_root_layer_;
   scoped_ptr<BrowserCompositorCALayerTreeMac> ca_layer_tree_;

[tapted, 2014/10/17 00:04:36]

is the plan to move this into a subclass of BrowserCompositorViewMac?

[ccameron, 2014/10/17 00:26:53]

Yes, exactly. I may go with something to the effect of
ui::NativeViewCompositorCocoa and ui::NativeViewCompositorCocoaImpl.

 };
 
 // A class to keep around whenever a BrowserCompositorViewMac may be created.
 // While at least one instance of this class exists, a spare
 // BrowserCompositorViewCocoa will be kept around to be recycled so that the
 // next BrowserCompositorViewMac to be created will be be created quickly.
 class BrowserCompositorViewPlaceholderMac {
  public:
   BrowserCompositorViewPlaceholderMac();
   ~BrowserCompositorViewPlaceholderMac();
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_BROWSER_COMPOSITOR_VIEW_MAC_H_