Add content::SurfaceCapturer

content/common/gpu/client/gl_surface_capturer_host.h

+// 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.
+
+#ifndef CONTENT_COMMON_GPU_CLIENT_GL_SURFACE_CAPTURER_HOST_H_
+#define CONTENT_COMMON_GPU_CLIENT_GL_SURFACE_CAPTURER_HOST_H_
+
+#include "base/containers/hash_tables.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
+#include "content/common/gpu/client/command_buffer_proxy_impl.h"
+#include "content/common/gpu/surface_capturer.h"
+#include "ipc/ipc_listener.h"
+
+namespace gfx {
+
+class Rect;
+class Size;
+
+}  // namespace gfx
+
+namespace media {
+
+class VideoFrame;
+
+}  // namespace media
+
+namespace content {
+
+class GpuChannelHost;
+
+// This class is the browser-side host for the SurfaceCapturer in the GPU
+// process, coordinated over IPC.
+class GLSurfaceCapturerHost : public IPC::Listener,
+                              public SurfaceCapturer,
+                              public CommandBufferProxyImpl::DeletionObserver {
+ public:
+  // |client| is expected to outlive this object.  We are registered as a
+  // DeletionObserver with |impl|, so it will notify us when it is about to
+  // be destroyed.
+  GLSurfaceCapturerHost(int32 capturer_route_id,
+                        SurfaceCapturer::Client* client,
+                        CommandBufferProxyImpl* impl);
+
+  // IPC::Listener implementation.
+  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  // SurfaceCapturer implementation.
+  virtual void Initialize(media::VideoFrame::Format format) OVERRIDE;
+  virtual void Capture(const scoped_refptr<media::VideoFrame>& frame) OVERRIDE;
+  virtual void Destroy() OVERRIDE;
+
+  // CommandBufferProxyImpl::DeletionObserver implementation.
+  virtual void OnWillDeleteImpl() OVERRIDE;
+
+ private:
+  virtual ~GLSurfaceCapturerHost();
+
+  // Notify |client_| when an error has occured.  Used when notifying from
+  // within a media::VideoEncodeAccelerator entry point, to avoid re-entrancy.
+  void NotifyError(Error error);
+
+  // IPC handlers, proxying SurfaceCapturer::Client for the GPU process.
+  void OnNotifyCaptureParameters(const gfx::Size& buffer_size,
+                                 const gfx::Rect& visible_rect);
+  void OnNotifyCaptureDone(int32 frame_id);
+  void OnNotifyError(Error error);
+
+  void Send(IPC::Message* message);
+
+  const base::ThreadChecker thread_checker_;

[hshi1, 2013/08/15 19:40:18]

const thread_checker_ not initialized in ctor.

[miu, 2013/08/15 20:22:08]

Is this in the C++ style guide?  On the surface, this seems perfectly reasonable
since the class has only a zero-arg constructor.

[hshi1, 2013/08/15 20:45:29]

Not a style violation but compile fails with message "error: uninitialized
member 'content::GLSurfaceCapturer::thread_checker_' with 'const' type 'const
base::ThreadChecker' [-fpermissive]".

+
+  // Route ID for corresponding GLSurfaceCapturer in the GPU process.
+  const int32 capturer_route_id_;
+
+  // SurfaceEncoder::Client callbacks received over IPC are forwarded to
+  // |client_|.  |client_ptr_factory_| is used for calls originating directly
+  // from a SurfaceEncoder interface function, that require an extra PostTask()
+  // back on its own thread to avoid re-entrancy.
+  // hop.
+  base::WeakPtrFactory<SurfaceCapturer::Client> client_ptr_factory_;
+  SurfaceCapturer::Client* client_;
+
+  // Unowned reference to the CommandBufferProxyImpl that created us.
+  CommandBufferProxyImpl* impl_;
+
+  // GPU process channel to send messages on.
+  GpuChannelHost* channel_;
+
+  // media::VideoFrames sent to the capturer.
+  // base::IDMap not used here, since that takes pointers, not scoped_refptr.
+  typedef base::hash_map<int32, scoped_refptr<media::VideoFrame> > FrameMap;
+  FrameMap frame_map_;
+
+  // ID serial number for next frame to send to the GPU process.
+  int32 next_frame_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(GLSurfaceCapturerHost);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_GPU_CLIENT_GL_SURFACE_CAPTURER_HOST_H_