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 <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.
+// The class to hold the ui::Compositor which is used to draw a NSView.
+// TODO(ccameron): This should implement an interface in the ui namespace.
 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);
+  // the NSView provided by the client. Note that |client|, |native_view|, and
+  // |ui_root_layer| outlive their BrowserCompositorViewMac object.
+  BrowserCompositorViewMac(
+      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.
+  // TODO(ccameron): This should be in the ui namespace interface.
   ui::Compositor* GetCompositor() const;

[danakj, 2014/10/17 00:30:33]

I wanna make sure we're on the right path and i'm understanding. This interface
is for content to implement and provide functionality to ui:: right? What code
in ui would need to use this to get the compositor?

[ccameron, 2014/10/17 00:40:14]

The NSView that owns this will be calling SetSizeAndScale on the ui::Compositor
(among any other properties that it wants to set).

[danakj, 2014/10/17 00:44:14]

OK. The NSView doesn't exist yet right? I guess it would have this thing as it's
only path to the Compositor? I was picturing a view as also having ui::Layers or
views::Widgets or something which also give you the compositor. It seems a bit
funny to have ui:: code ask content:: to give it back the ui::Compositor. But if
it makes sense then it does.

[ccameron, 2014/10/17 01:06:38]

Ah -- the NSView exists -- this class then goes in an messes around with the
drawing mechanism (the CALayers hiding behind the NSView) of the NSView when it
gets frames.

WRT the ui::Compositor being given to you by content, that's because of the way
that the ui::Compositors are recycled between tabs -- because we have a separate
NSView for each tab, we need to make sure that we don't alloc/free a
ui::Compositor per-tab.

[danakj, 2014/10/18 18:42:01]

OK. Maybe it would make sense to do that messing around in ui instead of
content? You'd wanna do the same thing with an inprocess GL too? But maybe it
doesn't work out, I'm not familiar enough to say. This LGTM for now anyhow.

 
-  // 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|.
+  // TODO(ccameron): This should be in the ui namespace interface.
   bool HasFrameOfSize(const gfx::Size& dip_size) const;

[danakj, 2014/10/17 00:30:33]

Similarly can you give a brief example or handwaving about what would use each
of these from ui::?

[ccameron, 2014/10/17 00:40:13]

The frame pumping bit is useful for making sure that you get a frame of a given
size up on the screen before the NSView has completed doing a resize. An example
would be:

GetCompositor()->SetSizeAndScale(newFrameSize)
BeginPumpingFrames()
while (!HasFrameOfSize(newFrameSize) && !timed_out)
  // pump run loop
EndPumpingFrames()

Trent's code only uses GetCompositor so far -- I could remove the
pumping/HasFrameOfSize functions for the time being -- I'll suspect he'll want
to use them eventually (although maybe we should leave them out until that need
becomes concrete).

[danakj, 2014/10/17 00:44:14]

OK thanks. Ya I'd add it when we need it.

[ccameron, 2014/10/17 01:06:38]

K -- removed the TODOs for these guys.

 
   // 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.
+  // TODO(ccameron): This should be in the ui namespace interface.
   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_;
+  ui::Layer* ui_root_layer_;
+
+  // 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
+  // BrowserCompositorCALayerTreeMac, which actually has a ui::Compositor
+  // instance and modifies the CALayers used to draw the NSView.
   scoped_ptr<BrowserCompositorCALayerTreeMac> ca_layer_tree_;
 };
 
 // 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_