Hook up BeginFrameSource to SurfaceFactoryClient via SurfaceManager

components/mus/ws/server_window_surface.cc

 // Copyright 2015 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/mus/ws/server_window_surface.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "components/mus/surfaces/surfaces_state.h"
@@ skipping 14 matching lines @@
 }  // namespace
 
 ServerWindowSurface::ServerWindowSurface(
     ServerWindowSurfaceManager* manager,
     mojom::SurfaceType surface_type,
     mojo::InterfaceRequest<Surface> request,
     mojom::SurfaceClientPtr client)
     : manager_(manager),
       surface_type_(surface_type),
       surface_id_(manager->GenerateId()),
-      surface_factory_(manager_->window()
-                           ->delegate()
-                           ->GetSurfacesState()
-                           ->manager(),
-                       this),
+      surface_factory_(manager_->GetSurfaceManager(), this),
       client_(std::move(client)),
-      binding_(this, std::move(request)) {
+      binding_(this, std::move(request)),
+      registered_surface_factory_client_(false) {
   surface_factory_.Create(surface_id_);
 }
 
 ServerWindowSurface::~ServerWindowSurface() {
   // SurfaceFactory's destructor will attempt to return resources which will
   // call back into here and access |client_| so we should destroy
   // |surface_factory_|'s resources early on.
   surface_factory_.DestroyAll();
+
+  if (registered_surface_factory_client_) {
+    SurfaceManager* manager = manager_->GetSurfaceManager();
+    manager->UnregisterSurfaceFactoryClient(manager_->id_namespace(), nullptr);
+  }
 }
 
 void ServerWindowSurface::SubmitCompositorFrame(
     mojom::CompositorFramePtr frame,
     const SubmitCompositorFrameCallback& callback) {
   gfx::Size frame_size = frame->passes[0]->output_rect.To<gfx::Rect>().size();
   if (!surface_id_.is_null()) {
     // If the size of the CompostiorFrame has changed then destroy the existing
     // Surface and create a new one of the appropriate size.
     if (frame_size != last_submitted_frame_size_) {
@@ skipping 17 matching lines @@
   last_submitted_frame_size_ = frame_size;
 }
 
 void ServerWindowSurface::DestroySurfacesScheduledForDestruction() {
   std::set<cc::SurfaceId> surfaces;
   surfaces.swap(surfaces_scheduled_for_destruction_);
   for (auto& id : surfaces)
     surface_factory_.Destroy(id);
 }
 
+void ServerWindowSurface::RegisterForBeginFrames() {
+  DCHECK(!registered_surface_factory_client_);
+  registered_surface_factory_client_ = true;
+  SurfaceManager* manager = manager_->GetSurfaceManager();
+  manager->RegisterSurfaceFactoryClient(manager_->id_namespace(), this);
+}
+
 ServerWindow* ServerWindowSurface::window() {
   return manager_->window();
 }
 
 scoped_ptr<cc::CompositorFrame> ServerWindowSurface::ConvertCompositorFrame(
     const mojom::CompositorFramePtr& input) {
   referenced_window_ids_.clear();
   return ConvertToCompositorFrame(input, this);
 }
 
@@ skipping 56 matching lines @@
 }
 
 void ServerWindowSurface::SetBeginFrameSource(
     cc::SurfaceId surface_id,
     cc::BeginFrameSource* begin_frame_source) {
   // TODO(tansell): Implement this.
 }
 
 }  // namespace ws
 }  // namespace mus