content/renderer/gpu/compositor_output_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_RENDERER_GPU_COMPOSITOR_OUTPUT_SURFACE_H_
   6 #define CONTENT_RENDERER_GPU_COMPOSITOR_OUTPUT_SURFACE_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/threading/non_thread_safe.h"
  14 #include "base/threading/platform_thread.h"
  15 #include "base/time/time.h"
  16 #include "cc/output/begin_frame_args.h"
  17 #include "cc/output/output_surface.h"
  18 #include "ipc/ipc_sync_message_filter.h"
  19
  20 namespace base {
  21 class TaskRunner;
  22 }
  23
  24 namespace IPC {
  25 class ForwardingMessageFilter;
  26 class Message;
  27 }
  28
  29 namespace cc {
  30 class CompositorFrame;
  31 class CompositorFrameAck;
  32 class GLFrameData;
  33 class SoftwareFrameData;
  34 }
  35
  36 namespace content {
  37 class ContextProviderCommandBuffer;
  38 class FrameSwapMessageQueue;
  39
  40 // This class can be created only on the main thread, but then becomes pinned
  41 // to a fixed thread when bindToClient is called.
  42 class CompositorOutputSurface
  43     : NON_EXPORTED_BASE(public cc::OutputSurface),
  44       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  45  public:
  46   static IPC::ForwardingMessageFilter* CreateFilter(
  47       base::TaskRunner* target_task_runner);
  48
  49   CompositorOutputSurface(
  50       int32 routing_id,
  51       uint32 output_surface_id,
  52       const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
  53       scoped_ptr<cc::SoftwareOutputDevice> software,
  54       scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue,
  55       bool use_swap_compositor_frame_message);
  56   virtual ~CompositorOutputSurface();
  57
  58   // cc::OutputSurface implementation.
  59   virtual bool BindToClient(cc::OutputSurfaceClient* client) OVERRIDE;
  60   virtual void SwapBuffers(cc::CompositorFrame* frame) OVERRIDE;
  61 #if defined(OS_ANDROID)
  62   virtual void SetNeedsBeginFrame(bool enable) OVERRIDE;
  63 #endif
  64
  65   // TODO(epenner): This seems out of place here and would be a better fit
  66   // int CompositorThread after it is fully refactored (http://crbug/170828)
  67   virtual void UpdateSmoothnessTakesPriority(bool prefer_smoothness) OVERRIDE;
  68
  69  protected:
  70   void ShortcutSwapAck(uint32 output_surface_id,
  71                        scoped_ptr<cc::GLFrameData> gl_frame_data,
  72                        scoped_ptr<cc::SoftwareFrameData> software_frame_data);
  73   virtual void OnSwapAck(uint32 output_surface_id,
  74                          const cc::CompositorFrameAck& ack);
  75   virtual void OnReclaimResources(uint32 output_surface_id,
  76                                   const cc::CompositorFrameAck& ack);
  77   uint32 output_surface_id_;
  78
  79  private:
  80   class CompositorOutputSurfaceProxy :
  81       public base::RefCountedThreadSafe<CompositorOutputSurfaceProxy> {
  82    public:
  83     explicit CompositorOutputSurfaceProxy(
  84         CompositorOutputSurface* output_surface)
  85         : output_surface_(output_surface) {}
  86     void ClearOutputSurface() { output_surface_ = NULL; }
  87     void OnMessageReceived(const IPC::Message& message) {
  88       if (output_surface_)
  89         output_surface_->OnMessageReceived(message);
  90     }
  91
  92    private:
  93     friend class base::RefCountedThreadSafe<CompositorOutputSurfaceProxy>;
  94     ~CompositorOutputSurfaceProxy() {}
  95     CompositorOutputSurface* output_surface_;
  96
  97     DISALLOW_COPY_AND_ASSIGN(CompositorOutputSurfaceProxy);
  98   };
  99
 100   void OnMessageReceived(const IPC::Message& message);
 101   void OnUpdateVSyncParametersFromBrowser(base::TimeTicks timebase,
 102                                           base::TimeDelta interval);
 103 #if defined(OS_ANDROID)
 104   void OnBeginFrame(const cc::BeginFrameArgs& args);
 105 #endif
 106   bool Send(IPC::Message* message);
 107
 108   bool use_swap_compositor_frame_message_;
 109
 110   scoped_refptr<IPC::ForwardingMessageFilter> output_surface_filter_;
 111   scoped_refptr<CompositorOutputSurfaceProxy> output_surface_proxy_;
 112   scoped_refptr<IPC::SyncMessageFilter> message_sender_;
 113   scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue_;
 114   int routing_id_;
 115   bool prefers_smoothness_;
 116   base::PlatformThreadHandle main_thread_handle_;
 117
 118   // TODO(danakj): Remove this when crbug.com/311404
 119   bool layout_test_mode_;
 120   scoped_ptr<cc::CompositorFrameAck> layout_test_previous_frame_ack_;
 121   base::WeakPtrFactory<CompositorOutputSurface> weak_ptrs_;
 122 };
 123
 124 }  // namespace content
 125
 126 #endif  // CONTENT_RENDERER_GPU_COMPOSITOR_OUTPUT_SURFACE_H_