Mandoline: Allow submitting CompositorFrames directly to mojo::Views

components/view_manager/connection_manager.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 COMPONENTS_VIEW_MANAGER_CONNECTION_MANAGER_H_
 #define COMPONENTS_VIEW_MANAGER_CONNECTION_MANAGER_H_
 
 #include <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
+#include "cc/surfaces/surface_factory.h"
+#include "cc/surfaces/surface_factory_client.h"
 #include "components/view_manager/animation_runner.h"
 #include "components/view_manager/event_dispatcher.h"
 #include "components/view_manager/focus_controller_delegate.h"
 #include "components/view_manager/ids.h"
 #include "components/view_manager/public/interfaces/view_manager.mojom.h"
 #include "components/view_manager/public/interfaces/view_manager_root.mojom.h"
 #include "components/view_manager/server_view_delegate.h"
 #include "components/view_manager/server_view_observer.h"
+#include "components/view_manager/surfaces/surfaces_state.h"
 #include "components/view_manager/view_manager_root_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/array.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 
 namespace view_manager {
 
 class ClientConnection;
 class ConnectionManagerDelegate;
 class FocusController;
 class ServerView;
 class ViewManagerRootConnection;
 class ViewManagerServiceImpl;
 
 // ConnectionManager manages the set of connections to the ViewManager (all the
 // ViewManagerServiceImpls) as well as providing the root of the hierarchy.
 class ConnectionManager : public ServerViewDelegate,
                           public ServerViewObserver,
-                          public FocusControllerDelegate {
+                          public FocusControllerDelegate,
+                          public cc::SurfaceFactoryClient {
  public:
   // Create when a ViewManagerServiceImpl is about to make a change. Ensures
   // clients are notified correctly.
   class ScopedChange {
    public:
     ScopedChange(ViewManagerServiceImpl* connection,
                  ConnectionManager* connection_manager,
                  bool is_delete_view);
     ~ScopedChange();
 
@@ skipping 14 matching lines @@
     ConnectionManager* connection_manager_;
     const mojo::ConnectionSpecificId connection_id_;
     const bool is_delete_view_;
 
     // See description of MarkConnectionAsMessaged/DidMessageConnection.
     std::set<mojo::ConnectionSpecificId> message_ids_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedChange);
   };
 
-  explicit ConnectionManager(ConnectionManagerDelegate* delegate);
+  ConnectionManager(
+      ConnectionManagerDelegate* delegate,
+      const scoped_refptr<surfaces::SurfacesState>& surfaces_state);
   ~ConnectionManager() override;
 
   // Adds a ViewManagerRoot.
   void AddRoot(ViewManagerRootConnection* root_connection);
 
   // Creates a new ServerView. The return value is owned by the caller, but must
   // be destroyed before ConnectionManager.
   ServerView* CreateServerView(const ViewId& id);
 
   // Returns the id for the next ViewManagerServiceImpl.
@@ skipping 101 matching lines @@
                                       const ServerView* new_parent,
                                       const ServerView* old_parent);
   void ProcessViewHierarchyChanged(const ServerView* view,
                                    const ServerView* new_parent,
                                    const ServerView* old_parent);
   void ProcessViewReorder(const ServerView* view,
                           const ServerView* relative_view,
                           const mojo::OrderDirection direction);
   void ProcessViewDeleted(const ViewId& view);
 
+  // SurfaceFactoryClient implementation.

[rjkroege, 2015/08/13 18:04:01]

is this right?

[Fady Samuel, 2015/08/17 21:11:11]

In what sense? It is an interface off SurfaceFactoryClient. It doesn't yet have
a meaningful implementation.

+  void ReturnResources(const cc::ReturnedResourceArray& resources) override;
+
  private:
   using ConnectionMap = std::map<mojo::ConnectionSpecificId, ClientConnection*>;
   using RootConnectionMap =
       std::map<ViewManagerRootImpl*, ViewManagerRootConnection*>;
 
   // Invoked when a connection is about to make a change.  Subsequently followed
   // by FinishChange() once the change is done.
   //
   // Changes should never nest, meaning each PrepareForChange() must be
   // balanced with a call to FinishChange() with no PrepareForChange()
@@ skipping 11 matching lines @@
   // Callback from animation timer.
   // TODO(sky): make this real (move to a different class).
   void DoAnimation();
 
   // Adds |connection| to internal maps.
   void AddConnection(ClientConnection* connection);
 
   ViewManagerRootImpl* GetViewManagerRootByView(const ServerView* view) const;
 
   // Overridden from ServerViewDelegate:
+  void SubmitFrame(ServerView* view,
+                   mojo::CompositorFramePtr frame,
+                   const mojo::Closure& callback) override;
   void PrepareToDestroyView(ServerView* view) override;
   void PrepareToChangeViewHierarchy(ServerView* view,
                                     ServerView* new_parent,
                                     ServerView* old_parent) override;
   void PrepareToChangeViewVisibility(ServerView* view) override;
   void OnScheduleViewPaint(const ServerView* view) override;
   const ServerView* GetRootView(const ServerView* view) const override;
 
   // Overridden from ServerViewObserver:
   void OnViewDestroyed(ServerView* view) override;
@@ skipping 18 matching lines @@
                                    const ui::TextInputState& state) override;
 
   void CloneAndAnimate(mojo::Id transport_view_id);
 
   // FocusControllerDelegate:
   void OnFocusChanged(ServerView* old_focused_view,
                       ServerView* new_focused_view) override;
 
   ConnectionManagerDelegate* delegate_;
 
+  scoped_refptr<surfaces::SurfacesState> surfaces_state_;
+
+  cc::SurfaceFactory surface_factory_;
+
   // ID to use for next ViewManagerServiceImpl.
   mojo::ConnectionSpecificId next_connection_id_;
 
   // ID to use for next ViewManagerRootImpl.
   uint16_t next_root_id_;
 
   EventDispatcher event_dispatcher_;
 
   // Set of ViewManagerServiceImpls.
   ConnectionMap connection_map_;
@@ skipping 13 matching lines @@
   AnimationRunner animation_runner_;
 
   scoped_ptr<FocusController> focus_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace view_manager
 
 #endif  // COMPONENTS_VIEW_MANAGER_CONNECTION_MANAGER_H_