Home | History | Annotate | Download | only in trees 
      1 // Copyright 2011 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 CC_TREES_PROXY_H_
      6 #define CC_TREES_PROXY_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/logging.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/threading/platform_thread.h"
     15 #include "base/time/time.h"
     16 #include "base/values.h"
     17 #include "cc/base/cc_export.h"
     18 
     19 namespace base {
     20 namespace debug {
     21 class TracedValue;
     22 }
     23 class SingleThreadTaskRunner;
     24 }
     25 
     26 namespace gfx {
     27 class Rect;
     28 class Vector2d;
     29 }
     30 
     31 namespace cc {
     32 class BlockingTaskRunner;
     33 class LayerTreeDebugState;
     34 class OutputSurface;
     35 struct RendererCapabilities;
     36 
     37 // Abstract class responsible for proxying commands from the main-thread side of
     38 // the compositor over to the compositor implementation.
     39 class CC_EXPORT Proxy {
     40  public:
     41   base::SingleThreadTaskRunner* MainThreadTaskRunner() const;
     42   bool HasImplThread() const;
     43   base::SingleThreadTaskRunner* ImplThreadTaskRunner() const;
     44 
     45   // Debug hooks.
     46   bool IsMainThread() const;
     47   bool IsImplThread() const;
     48   bool IsMainThreadBlocked() const;
     49 #if DCHECK_IS_ON
     50   void SetMainThreadBlocked(bool is_main_thread_blocked);
     51   void SetCurrentThreadIsImplThread(bool is_impl_thread);
     52 #endif
     53 
     54   virtual ~Proxy();
     55 
     56   virtual void FinishAllRendering() = 0;
     57 
     58   virtual bool IsStarted() const = 0;
     59 
     60   // Will call LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted
     61   // with the result of this function.
     62   virtual void SetOutputSurface(scoped_ptr<OutputSurface> output_surface) = 0;
     63 
     64   // Indicates that the compositing surface associated with our context is
     65   // ready to use.
     66   virtual void SetLayerTreeHostClientReady() = 0;
     67 
     68   virtual void SetVisible(bool visible) = 0;
     69 
     70   virtual const RendererCapabilities& GetRendererCapabilities() const = 0;
     71 
     72   virtual void SetNeedsAnimate() = 0;
     73   virtual void SetNeedsUpdateLayers() = 0;
     74   virtual void SetNeedsCommit() = 0;
     75   virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) = 0;
     76   virtual void SetNextCommitWaitsForActivation() = 0;
     77 
     78   virtual void NotifyInputThrottledUntilCommit() = 0;
     79 
     80   // Defers commits until it is reset. It is only supported when in threaded
     81   // mode. It's an error to make a sync call like CompositeAndReadback while
     82   // commits are deferred.
     83   virtual void SetDeferCommits(bool defer_commits) = 0;
     84 
     85   virtual void MainThreadHasStoppedFlinging() = 0;
     86 
     87   virtual bool CommitRequested() const = 0;
     88   virtual bool BeginMainFrameRequested() const = 0;
     89 
     90   // Must be called before using the proxy.
     91   virtual void Start() = 0;
     92   virtual void Stop() = 0;   // Must be called before deleting the proxy.
     93 
     94   // Forces 3D commands on all contexts to wait for all previous SwapBuffers
     95   // to finish before executing in the GPU process.
     96   virtual void ForceSerializeOnSwapBuffers() = 0;
     97 
     98   // Maximum number of sub-region texture updates supported for each commit.
     99   virtual size_t MaxPartialTextureUpdates() const = 0;
    100 
    101   virtual bool SupportsImplScrolling() const = 0;
    102 
    103   virtual void AsValueInto(base::debug::TracedValue* value) const = 0;
    104 
    105   virtual void SetDebugState(const LayerTreeDebugState& debug_state) = 0;
    106 
    107   // Testing hooks
    108   virtual bool MainFrameWillHappenForTesting() = 0;
    109 
    110   BlockingTaskRunner* blocking_main_thread_task_runner() const {
    111     return blocking_main_thread_task_runner_.get();
    112   }
    113 
    114  protected:
    115   Proxy(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
    116         scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
    117   friend class DebugScopedSetImplThread;
    118   friend class DebugScopedSetMainThread;
    119   friend class DebugScopedSetMainThreadBlocked;
    120 
    121  private:
    122   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
    123   scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
    124   scoped_ptr<BlockingTaskRunner> blocking_main_thread_task_runner_;
    125 
    126 #if DCHECK_IS_ON
    127   const base::PlatformThreadId main_thread_id_;
    128   bool impl_thread_is_overridden_;
    129   bool is_main_thread_blocked_;
    130 #endif
    131 
    132   DISALLOW_COPY_AND_ASSIGN(Proxy);
    133 };
    134 
    135 #if DCHECK_IS_ON
    136 class DebugScopedSetMainThreadBlocked {
    137  public:
    138   explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) : proxy_(proxy) {
    139     DCHECK(!proxy_->IsMainThreadBlocked());
    140     proxy_->SetMainThreadBlocked(true);
    141   }
    142   ~DebugScopedSetMainThreadBlocked() {
    143     DCHECK(proxy_->IsMainThreadBlocked());
    144     proxy_->SetMainThreadBlocked(false);
    145   }
    146  private:
    147   Proxy* proxy_;
    148   DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked);
    149 };
    150 #else
    151 class DebugScopedSetMainThreadBlocked {
    152  public:
    153   explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) {}
    154   ~DebugScopedSetMainThreadBlocked() {}
    155  private:
    156   DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked);
    157 };
    158 #endif
    159 
    160 }  // namespace cc
    161 
    162 #endif  // CC_TREES_PROXY_H_
    163