Add observers to FrameSinkManagerHost.

content/browser/compositor/frame_sink_manager_host.h

 // Copyright 2017 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_FRAME_SINK_MANAGER_HOST_H_
 #define CONTENT_BROWSER_COMPOSITOR_FRAME_SINK_MANAGER_HOST_H_
 
+#include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/observer_list.h"
 #include "cc/ipc/frame_sink_manager.mojom.h"
 #include "cc/surfaces/frame_sink_id.h"
+#include "cc/surfaces/surface_observer.h"
 #include "components/viz/frame_sinks/mojo_frame_sink_manager.h"
+#include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace cc {
 class SurfaceInfo;
 class SurfaceManager;
 }
 
 namespace content {
 
 // Browser side implementation of mojom::FrameSinkManager. Manages frame sinks
-// and is inteded to replace SurfaceManager.
-class FrameSinkManagerHost : cc::mojom::FrameSinkManagerClient {
+// and is intended to replace SurfaceManager.
+class CONTENT_EXPORT FrameSinkManagerHost
+    : NON_EXPORTED_BASE(cc::mojom::FrameSinkManagerClient) {
  public:
   FrameSinkManagerHost();
   ~FrameSinkManagerHost() override;
 
   cc::SurfaceManager* surface_manager();
 
+  void AddObserver(cc::SurfaceObserver* observer);

[Fady Samuel, 2017/04/11 16:43:53]

Maybe I'm being pedantic but SurfaceObserver seems like a part of SurfaceManager
which is an implementation detail of the display compositor. I feel like we
should have a content-side observer.

[kylechar, 2017/04/11 16:52:39]

Ya, I think that's sounds totally reasonable to have a different observer base
type and maybe even different semantics.

Although, for now it might be easier to reuse SurfaceObserver because we can
then use it with both SurfaceManager or FrameSinkManagerHost. This will allow
using non-Mojo or Mojo at runtime based on a flag while performance is evaluated
(eg. for RendererCompositorFrameSink).

[kylechar, 2017/04/11 16:53:30]

If so, I should add a TODO saying as much.

[Fady Samuel, 2017/04/11 17:02:47]

It seems like those things are orthogonal.

FrameSinkManagerHost can observe SurfaceManager directly and forward
OnSurfaceCreated via another observer interface?

+  void RemoveObserver(cc::SurfaceObserver* observer);
+
   // See frame_sink_manager.mojom for descriptions.
   void CreateCompositorFrameSink(
       const cc::FrameSinkId& frame_sink_id,
       cc::mojom::MojoCompositorFrameSinkRequest request,
       cc::mojom::MojoCompositorFrameSinkPrivateRequest private_request,
       cc::mojom::MojoCompositorFrameSinkClientPtr client);
   void RegisterFrameSinkHierarchy(const cc::FrameSinkId& parent_frame_sink_id,
                                   const cc::FrameSinkId& child_frame_sink_id);
   void UnregisterFrameSinkHierarchy(const cc::FrameSinkId& parent_frame_sink_id,
                                     const cc::FrameSinkId& child_frame_sink_id);
 
  private:
   // cc::mojom::FrameSinkManagerClient:
   void OnSurfaceCreated(const cc::SurfaceInfo& surface_info) override;
 
   // Mojo connection to |frame_sink_manager_|.
   cc::mojom::FrameSinkManagerPtr frame_sink_manager_ptr_;
 
   // Mojo connection back from |frame_sink_manager_|.
   mojo::Binding<cc::mojom::FrameSinkManagerClient> binding_;
 
   // This is owned here so that SurfaceManager will be accessible in process.
   // Other than using SurfaceManager, access to |frame_sink_manager_| should
   // happen using Mojo. See http://crbug.com/657959.
   viz::MojoFrameSinkManager frame_sink_manager_;
 
+  base::ObserverList<cc::SurfaceObserver> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(FrameSinkManagerHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_FRAME_SINK_MANAGER_HOST_H_