All together now

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 76 matching lines @@
   if (!shared_contexts_main_thread_.get())
     return NULL;
   scoped_refptr<OwnedTexture> image(new OwnedTexture(
       shared_contexts_main_thread_->Context3d(),
       size,
       device_scale_factor,
       texture_id));
   return image;
 }
 
+scoped_ptr<SurfaceCapturer>
+GpuProcessTransportFactory::CreateOutputSurfaceCapturer(
+    ui::Compositor* compositor,
+    SurfaceCapturer::Client* client) {
+  PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
+  if (it == per_compositor_data_.end())
+    return scoped_ptr<SurfaceCapturer>();
+  PerCompositorData* data = it->second;
+  DCHECK(data);
+  return scoped_ptr<SurfaceCapturer>(new BrowserCompositorOutputSurfaceCapturer(
+      &output_surface_map_, data->surface_id, client));
+}
+
 GLHelper* GpuProcessTransportFactory::GetGLHelper() {
   if (!gl_helper_) {
     CreateSharedContextLazy();
     WebGraphicsContext3DCommandBufferImpl* context_for_main_thread =
         shared_contexts_main_thread_->Context3d();
     gl_helper_.reset(new GLHelper(context_for_main_thread));
   }
   return gl_helper_.get();
 }
 
@@ skipping 151 matching lines @@
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_shared_contexts_main_thread = NULL;
   lost_shared_contexts_compositor_thread = NULL;
 }
 
 }  // namespace content