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