content/common/gpu/image_transport_surface.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_H_
   6 #define CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_H_
   7
   8 #include <vector>
   9
  10 #include "base/callback.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "content/common/content_export.h"
  16 #include "ipc/ipc_listener.h"
  17 #include "ipc/ipc_message.h"
  18 #include "ui/events/latency_info.h"
  19 #include "ui/gfx/geometry/rect.h"
  20 #include "ui/gfx/geometry/size.h"
  21 #include "ui/gfx/native_widget_types.h"
  22 #include "ui/gl/gl_surface.h"
  23
  24 struct AcceleratedSurfaceMsg_BufferPresented_Params;
  25 struct GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params;
  26
  27 namespace gfx {
  28 class GLSurface;
  29 }
  30
  31 namespace gpu {
  32 class PreemptionFlag;
  33 namespace gles2 {
  34 class GLES2Decoder;
  35 }
  36 }
  37
  38 namespace content {
  39 class GpuChannelManager;
  40 class GpuCommandBufferStub;
  41
  42 // The GPU process is agnostic as to how it displays results. On some platforms
  43 // it renders directly to window. On others it renders offscreen and transports
  44 // the results to the browser process to display. This file provides a simple
  45 // framework for making the offscreen path seem more like the onscreen path.
  46 //
  47 // The ImageTransportSurface class defines an simple interface for events that
  48 // should be responded to. The factory returns an offscreen surface that looks
  49 // a lot like an onscreen surface to the GPU process.
  50 //
  51 // The ImageTransportSurfaceHelper provides some glue to the outside world:
  52 // making sure outside events reach the ImageTransportSurface and
  53 // allowing the ImageTransportSurface to send events to the outside world.
  54
  55 class ImageTransportSurface {
  56  public:
  57   ImageTransportSurface();
  58
  59 #if defined(OS_MACOSX)
  60   virtual void OnBufferPresented(
  61       const AcceleratedSurfaceMsg_BufferPresented_Params& params) = 0;
  62 #endif
  63   virtual void OnResize(gfx::Size size, float scale_factor) = 0;
  64   virtual void SetLatencyInfo(
  65       const std::vector<ui::LatencyInfo>& latency_info) = 0;
  66   virtual void WakeUpGpu() = 0;
  67
  68   // Creates a surface with the given attributes.
  69   static scoped_refptr<gfx::GLSurface> CreateSurface(
  70       GpuChannelManager* manager,
  71       GpuCommandBufferStub* stub,
  72       const gfx::GLSurfaceHandle& handle);
  73
  74 #if defined(OS_MACOSX)
  75   CONTENT_EXPORT static void SetAllowOSMesaForTesting(bool allow);
  76 #endif
  77
  78   virtual gfx::Size GetSize() = 0;
  79
  80  protected:
  81   virtual ~ImageTransportSurface();
  82
  83  private:
  84   // Creates the appropriate native surface depending on the GL implementation.
  85   // This will be implemented separately by each platform.
  86   //
  87   // This will not be called for texture transport surfaces which are
  88   // cross-platform. The platform implementation should only create the
  89   // surface and should not initialize it. On failure, a null scoped_refptr
  90   // should be returned.
  91   static scoped_refptr<gfx::GLSurface> CreateNativeSurface(
  92       GpuChannelManager* manager,
  93       GpuCommandBufferStub* stub,
  94       const gfx::GLSurfaceHandle& handle);
  95
  96 #if defined(OS_ANDROID)
  97   static scoped_refptr<gfx::GLSurface> CreateTransportSurface(
  98       GpuChannelManager* manager,
  99       GpuCommandBufferStub* stub,
 100       const gfx::GLSurfaceHandle& handle);
 101 #endif
 102
 103   DISALLOW_COPY_AND_ASSIGN(ImageTransportSurface);
 104 };
 105
 106 class ImageTransportHelper
 107     : public IPC::Listener,
 108       public base::SupportsWeakPtr<ImageTransportHelper> {
 109  public:
 110   // Takes weak pointers to objects that outlive the helper.
 111   ImageTransportHelper(ImageTransportSurface* surface,
 112                        GpuChannelManager* manager,
 113                        GpuCommandBufferStub* stub,
 114                        gfx::PluginWindowHandle handle);
 115   ~ImageTransportHelper() override;
 116
 117   bool Initialize();
 118
 119   // IPC::Listener implementation:
 120   bool OnMessageReceived(const IPC::Message& message) override;
 121
 122   // Helper send functions. Caller fills in the surface specific params
 123   // like size and surface id. The helper fills in the rest.
 124   void SendAcceleratedSurfaceBuffersSwapped(
 125       GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params);
 126
 127   void SetPreemptByFlag(
 128       scoped_refptr<gpu::PreemptionFlag> preemption_flag);
 129
 130   // Make the surface's context current.
 131   bool MakeCurrent();
 132
 133   // Set the default swap interval on the surface.
 134   static void SetSwapInterval(gfx::GLContext* context);
 135
 136   GpuChannelManager* manager() const { return manager_; }
 137   GpuCommandBufferStub* stub() const { return stub_.get(); }
 138
 139  private:
 140   gpu::gles2::GLES2Decoder* Decoder();
 141
 142   // IPC::Message handlers.
 143 #if defined(OS_MACOSX)
 144   void OnBufferPresented(
 145       const AcceleratedSurfaceMsg_BufferPresented_Params& params);
 146 #endif
 147   void OnWakeUpGpu();
 148
 149   // Backbuffer resize callback.
 150   void Resize(gfx::Size size, float scale_factor);
 151
 152   void SetLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info);
 153
 154   // Weak pointers that point to objects that outlive this helper.
 155   ImageTransportSurface* surface_;
 156   GpuChannelManager* manager_;
 157
 158   base::WeakPtr<GpuCommandBufferStub> stub_;
 159   int32 route_id_;
 160   gfx::PluginWindowHandle handle_;
 161
 162   DISALLOW_COPY_AND_ASSIGN(ImageTransportHelper);
 163 };
 164
 165 // An implementation of ImageTransportSurface that implements GLSurface through
 166 // GLSurfaceAdapter, thereby forwarding GLSurface methods through to it.
 167 class PassThroughImageTransportSurface
 168     : public gfx::GLSurfaceAdapter,
 169       public ImageTransportSurface {
 170  public:
 171   PassThroughImageTransportSurface(GpuChannelManager* manager,
 172                                    GpuCommandBufferStub* stub,
 173                                    gfx::GLSurface* surface);
 174
 175   // GLSurface implementation.
 176   bool Initialize() override;
 177   void Destroy() override;
 178   bool SwapBuffers() override;
 179   bool PostSubBuffer(int x, int y, int width, int height) override;
 180   bool OnMakeCurrent(gfx::GLContext* context) override;
 181
 182   // ImageTransportSurface implementation.
 183 #if defined(OS_MACOSX)
 184   void OnBufferPresented(
 185       const AcceleratedSurfaceMsg_BufferPresented_Params& params) override;
 186 #endif
 187   void OnResize(gfx::Size size, float scale_factor) override;
 188   gfx::Size GetSize() override;
 189   void SetLatencyInfo(
 190       const std::vector<ui::LatencyInfo>& latency_info) override;
 191   void WakeUpGpu() override;
 192
 193  protected:
 194   ~PassThroughImageTransportSurface() override;
 195
 196   // If updated vsync parameters can be determined, send this information to
 197   // the browser.
 198   virtual void SendVSyncUpdateIfAvailable();
 199   void SwapBuffersCallBack();
 200
 201   ImageTransportHelper* GetHelper() { return helper_.get(); }
 202
 203  private:
 204   scoped_ptr<ImageTransportHelper> helper_;
 205   bool did_set_swap_interval_;
 206   std::vector<ui::LatencyInfo> latency_info_;
 207   base::WeakPtrFactory<PassThroughImageTransportSurface> weak_ptr_factory_;
 208
 209   DISALLOW_COPY_AND_ASSIGN(PassThroughImageTransportSurface);
 210 };
 211
 212 }  // namespace content
 213
 214 #endif  // CONTENT_COMMON_GPU_IMAGE_TRANSPORT_SURFACE_H_