Hook up ui::Compositor to Display's BeginFrameSource

ui/compositor/test/in_process_context_factory.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 "ui/compositor/test/in_process_context_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 28 matching lines @@
   void AddMirroringLayer(Layer* layer) override {}
   void RemoveMirroringLayer(Layer* layer) override {}
 };
 
 // An OutputSurface implementation that directly draws and swaps to an actual
 // GL surface.
 class DirectOutputSurface : public cc::OutputSurface {
  public:
   DirectOutputSurface(
       const scoped_refptr<cc::ContextProvider>& context_provider,
-      const scoped_refptr<cc::ContextProvider>& worker_context_provider)
+      const scoped_refptr<cc::ContextProvider>& worker_context_provider,
+      scoped_ptr<cc::BeginFrameSource> begin_frame_source)
       : cc::OutputSurface(context_provider, worker_context_provider),
+        begin_frame_source_(std::move(begin_frame_source)),
         weak_ptr_factory_(this) {}
 
   ~DirectOutputSurface() override {}
 
   // cc::OutputSurface implementation
+  bool BindToClient(cc::OutputSurfaceClient* client) override {
+    if (!OutputSurface::BindToClient(client))
+      return false;
+
+    client->SetBeginFrameSource(begin_frame_source_.get());
+    return true;
+  }
   void SwapBuffers(cc::CompositorFrame* frame) override {
     DCHECK(context_provider_.get());
     DCHECK(frame->gl_frame_data);
     if (frame->gl_frame_data->sub_buffer_rect ==
         gfx::Rect(frame->gl_frame_data->size)) {
       context_provider_->ContextSupport()->Swap();
     } else {
       context_provider_->ContextSupport()->PartialSwapBuffers(
           frame->gl_frame_data->sub_buffer_rect);
     }
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
     gl->ShallowFlushCHROMIUM();
 
     gpu::SyncToken sync_token;
     gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
     context_provider_->ContextSupport()->SignalSyncToken(
         sync_token, base::Bind(&OutputSurface::OnSwapBuffersComplete,
                                weak_ptr_factory_.GetWeakPtr()));
     client_->DidSwapBuffers();
   }
 
  private:
+  scoped_ptr<cc::BeginFrameSource> begin_frame_source_;
+
   base::WeakPtrFactory<DirectOutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectOutputSurface);
 };
 
 }  // namespace
 
 InProcessContextFactory::InProcessContextFactory(
     bool context_factory_for_test,
     cc::SurfaceManager* surface_manager)
@@ skipping 43 matching lines @@
     shared_worker_context_provider_ = InProcessContextProvider::CreateOffscreen(
         &gpu_memory_buffer_manager_, &image_factory_);
     if (shared_worker_context_provider_ &&
         !shared_worker_context_provider_->BindToCurrentThread())
       shared_worker_context_provider_ = nullptr;
     if (shared_worker_context_provider_)
       shared_worker_context_provider_->SetupLock();
   }
 
   scoped_ptr<cc::OutputSurface> real_output_surface;
+  scoped_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
+      new cc::SyntheticBeginFrameSource(compositor->task_runner().get(),
+                                        cc::BeginFrameArgs::DefaultInterval()));
 
   if (use_test_surface_) {
     bool flipped_output_surface = false;
     real_output_surface = make_scoped_ptr(new cc::PixelTestOutputSurface(
         context_provider, shared_worker_context_provider_,
-        flipped_output_surface));
+        flipped_output_surface, std::move(begin_frame_source)));
   } else {
     real_output_surface = make_scoped_ptr(new DirectOutputSurface(
-        context_provider, shared_worker_context_provider_));
+        context_provider, shared_worker_context_provider_,
+        std::move(begin_frame_source)));
   }
 
   if (surface_manager_) {
     scoped_ptr<cc::OnscreenDisplayClient> display_client(
         new cc::OnscreenDisplayClient(
             std::move(real_output_surface), surface_manager_,
             GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
-            compositor->GetRendererSettings(), compositor->task_runner()));
+            compositor->GetRendererSettings(), compositor->task_runner(),
+            compositor->surface_id_allocator()->id_namespace()));
     scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
         new cc::SurfaceDisplayOutputSurface(
             surface_manager_, compositor->surface_id_allocator(),
             context_provider, shared_worker_context_provider_));
     display_client->set_surface_output_surface(surface_output_surface.get());
     surface_output_surface->set_display_client(display_client.get());
 
     compositor->SetOutputSurface(std::move(surface_output_surface));
 
     delete per_compositor_data_[compositor.get()];
@@ skipping 68 matching lines @@
 }
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
   if (!per_compositor_data_.count(compositor))
     return;
   per_compositor_data_[compositor]->display()->Resize(size);
 }
 
 }  // namespace ui