Mandoline: Allow submitting CompositorFrames directly to mojo::Views

components/view_manager/connection_manager.cc

 // 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 "components/view_manager/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/surfaces/surface_id_allocator.h"
 #include "components/view_manager/client_connection.h"
 #include "components/view_manager/connection_manager_delegate.h"
 #include "components/view_manager/focus_controller.h"
 #include "components/view_manager/server_view.h"
 #include "components/view_manager/view_coordinate_conversions.h"
 #include "components/view_manager/view_manager_root_connection.h"
 #include "components/view_manager/view_manager_service_impl.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
+#include "mojo/converters/surfaces/surfaces_type_converters.h"
 
 using mojo::ConnectionSpecificId;
 
 namespace view_manager {
 namespace {
 
+namespace {
+void CallCallback(const mojo::Closure& callback, cc::SurfaceDrawStatus status) {
+  callback.Run();
+}
+}
+
 // Creates a copy of |view|. The copied view has |delegate| as its delegate.
 // This does not recurse.
 ServerView* CloneView(const ServerView* view, ServerViewDelegate* delegate) {
   ServerView* clone = new ServerView(delegate, ClonedViewId());
   clone->SetBounds(view->bounds());
   clone->SetSurfaceId(view->surface_id());
   clone->SetOpacity(view->opacity());
   return clone;
 }
 
@@ skipping 68 matching lines @@
     : connection_manager_(connection_manager),
       connection_id_(connection->id()),
       is_delete_view_(is_delete_view) {
   connection_manager_->PrepareForChange(this);
 }
 
 ConnectionManager::ScopedChange::~ScopedChange() {
   connection_manager_->FinishChange();
 }
 
-ConnectionManager::ConnectionManager(ConnectionManagerDelegate* delegate)
+ConnectionManager::ConnectionManager(
+    ConnectionManagerDelegate* delegate,
+    const scoped_refptr<surfaces::SurfacesState>& surfaces_state)
     : delegate_(delegate),
+      surfaces_state_(surfaces_state),
       next_connection_id_(1),
       next_root_id_(0),
       event_dispatcher_(this),
       current_change_(nullptr),
       in_destructor_(false),
       animation_runner_(base::TimeTicks::Now()),
       focus_controller_(new FocusController(this)) {
 }
 
 ConnectionManager::~ConnectionManager() {
@@ skipping 318 matching lines @@
   }
 }
 
 void ConnectionManager::ProcessViewDeleted(const ViewId& view) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewDeleted(view,
                                                IsChangeSource(pair.first));
   }
 }
 
+void ConnectionManager::ReturnResources(

[rjkroege, 2015/08/19 23:45:44]

this is not how I plumbed it

[Fady Samuel, 2015/08/20 16:22:44]

Feel free to change. This boilerplate code exists to remind us to implement
this.

+    const cc::ReturnedResourceArray& resources) {
+  // TODO(fsamuel): Implement this.
+}
+
 void ConnectionManager::ProcessViewportMetricsChanged(
     const mojo::ViewportMetrics& old_metrics,
     const mojo::ViewportMetrics& new_metrics) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewportMetricsChanged(
         old_metrics, new_metrics, IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::PrepareForChange(ScopedChange* change) {
@@ skipping 27 matching lines @@
     const ServerView* view) const {
   while (view && view->parent())
     view = view->parent();
   for (auto& pair : root_connection_map_) {
     if (view == pair.first->root_view())
       return pair.first;
   }
   return nullptr;
 }
 
+void ConnectionManager::SubmitCompositorFrame(ServerView* view,
+                                              mojo::CompositorFramePtr frame,
+                                              const mojo::Closure& callback) {
+  // Create Surfaces state on demand.
+  if (!surface_factory_) {
+    surface_factory_.reset(
+        new cc::SurfaceFactory(surfaces_state_->manager(), this));
+  }
+
+  if (!surface_id_allocator_) {
+    surface_id_allocator_.reset(
+        new cc::SurfaceIdAllocator(surfaces_state_->next_id_namespace()));
+  }
+
+
+  if (view->surface_id().is_null()) {
+    // Create a Surface ID for the first time for this view.
+    cc::SurfaceId surface_id(surface_id_allocator_->GenerateId());
+    surface_factory_->Create(surface_id);
+    view->SetSurfaceId(surface_id);
+  } else {
+    // If the size of the CompostiorFrame has changed then destroy the existing
+    // Surface and create a new one of the appropriate size.
+    gfx::Size frame_size =
+        frame->passes[0]->output_rect.To<gfx::Rect>().size();
+    if (frame_size != view->last_submitted_frame_size()) {
+      surface_factory_->Destroy(view->surface_id());
+      cc::SurfaceId surface_id(surface_id_allocator_->GenerateId());
+      surface_factory_->Create(surface_id);
+      view->SetSurfaceId(surface_id);
+    }
+  }
+
+  surface_factory_->SubmitFrame(view->surface_id(),
+                                frame.To<scoped_ptr<cc::CompositorFrame>>(),
+                                base::Bind(&CallCallback, callback));
+  surfaces_state_->scheduler()->SetNeedsDraw();
+}
+
 void ConnectionManager::PrepareToDestroyView(ServerView* view) {
   if (!in_destructor_ && IsViewAttachedToRoot(view) &&
       view->id() != ClonedViewId()) {
     // We're about to destroy a view. Any cloned views need to be reparented
     // else the animation would no longer be visible. By moving to a visible
     // view, view->parent(), we ensure the animation is still visible.
     ServerView* parent_above = view;
     ReparentClonedViews(view->parent(), &parent_above, view);
   }
 
@@ skipping 201 matching lines @@
 
   if (new_view_manager_root) {
     new_view_manager_root->UpdateTextInputState(
         new_focused_view->text_input_state());
   } else if (old_view_manager_root) {
     old_view_manager_root->UpdateTextInputState(ui::TextInputState());
   }
 }
 
 }  // namespace view_manager