Add content::SurfaceCapturer

content/browser/aura/gpu_process_transport_factory.cc

 // Copyright (c) 2013 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 "content/browser/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
 #include "content/browser/aura/browser_compositor_output_surface.h"
+#include "content/browser/aura/browser_compositor_output_surface_capturer.h"
 #include "content/browser/aura/browser_compositor_output_surface_proxy.h"
 #include "content/browser/aura/reflector_impl.h"
 #include "content/browser/aura/software_browser_compositor_output_surface.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
@@ skipping 218 matching lines @@
       ui::Compositor::GetCompositorMessageLoop();
   if (!compositor_thread_task_runner.get())
     compositor_thread_task_runner = base::MessageLoopProxy::current();
 
   // Here we know the GpuProcessHost has been set up, because we created a
   // context.
   output_surface_proxy_->ConnectToGpuProcessHost(
       compositor_thread_task_runner.get());
 
   scoped_ptr<BrowserCompositorOutputSurface> surface(
-      new BrowserCompositorOutputSurface(
-          context_provider,
-          per_compositor_data_[compositor]->surface_id,
-          &output_surface_map_,
-          base::MessageLoopProxy::current().get(),
-          compositor->AsWeakPtr()));
+      new BrowserCompositorOutputSurface(context_provider,
+                                         data->surface_id,
+                                         &output_surface_map_,
+                                         base::MessageLoopProxy::current(),
+                                         compositor->AsWeakPtr()));
   if (data->reflector.get()) {
     data->reflector->CreateSharedTexture();
     data->reflector->AttachToOutputSurface(surface.get());
   }
 
   return surface.PassAs<cc::OutputSurface>();
 }
 
 scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source,
@@ skipping 30 matching lines @@
   DCHECK(data);
   GpuSurfaceTracker::Get()->RemoveSurface(data->surface_id);
   delete data;
   per_compositor_data_.erase(it);
   if (per_compositor_data_.empty())
     gl_helper_.reset();
 }
 
 bool GpuProcessTransportFactory::DoesCreateTestContexts() { return false; }
 
+scoped_ptr<SurfaceCapturer>
+GpuProcessTransportFactory::CreateOutputSurfaceCapturer(
+    ui::Compositor* compositor,
+    SurfaceCapturer::Client* client) {
+  scoped_ptr<SurfaceCapturer> capturer;
+  PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
+  if (it == per_compositor_data_.end())
+    return capturer.Pass();
+  PerCompositorData* data = it->second;
+  DCHECK(data);
+  capturer.reset(new BrowserCompositorOutputSurfaceCapturer(
+      &output_surface_map_, data->surface_id, client));
+  return capturer.Pass();
+}
+
 ui::ContextFactory* GpuProcessTransportFactory::AsContextFactory() {
   return this;
 }
 
+SurfaceCapturingContextFactory*
+GpuProcessTransportFactory::AsSurfaceCapturingContextFactory() {
+  return this;
+}
+
 gfx::GLSurfaceHandle GpuProcessTransportFactory::CreateSharedSurfaceHandle() {
   CreateSharedContextLazy();
   if (!shared_contexts_main_thread_ ||
       !shared_contexts_main_thread_->Context3d())
     return gfx::GLSurfaceHandle();
   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
       gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);
   handle.parent_gpu_process_id =
       shared_contexts_main_thread_->Context3d()->GetGPUProcessID();
   handle.parent_client_id =
@@ skipping 177 matching lines @@
   shared_contexts_main_thread_ = NULL;
 
   scoped_ptr<GLHelper> old_helper(gl_helper_.release());
 
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 }
 
 }  // namespace content