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/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_
    127