aura: Clean up compositor initialization/destruction.

ui/compositor/compositor.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 81 matching lines @@
   // Removes the reflector, which stops the mirroring.
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) = 0;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() = 0;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() = 0;
 
   // Destroys per-compositor data.
   virtual void RemoveCompositor(Compositor* compositor) = 0;
+
+  // When true, the factory uses test contexts that do not do real GL
+  // operations.
+  virtual bool UsesTestContexts() = 0;
 };
 
 // The default factory that creates in-process contexts.
 class COMPOSITOR_EXPORT DefaultContextFactory : public ContextFactory {
  public:
   DefaultContextFactory();
   virtual ~DefaultContextFactory();
 
   // ContextFactory implementation
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
       Compositor* compositor) OVERRIDE;
   virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext()
       OVERRIDE;
 
   virtual scoped_refptr<Reflector> CreateReflector(
       Compositor* compositor,
       Layer* layer) OVERRIDE;
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) OVERRIDE;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE;
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
+  virtual bool UsesTestContexts() OVERRIDE;
 
   bool Initialize();
 
  private:
   scoped_ptr<WebKit::WebGraphicsContext3D> CreateContextCommon(
       Compositor* compositor,
       bool offscreen);
 
   scoped_refptr<ContextProviderFromContextFactory>
       offscreen_contexts_main_thread_;
@@ skipping 18 matching lines @@
   virtual scoped_refptr<Reflector> CreateReflector(
       Compositor* mirrored_compositor,
       Layer* mirroring_layer) OVERRIDE;
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) OVERRIDE;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE;
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
+  virtual bool UsesTestContexts() OVERRIDE;
 
  private:
   scoped_refptr<ContextProviderFromContextFactory>
       offscreen_contexts_main_thread_;
   scoped_refptr<ContextProviderFromContextFactory>
       offscreen_contexts_compositor_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestContextFactory);
 };
 
@@ skipping 109 matching lines @@
 // appropriately transformed texture for each transformed view in the widget's
 // view hierarchy.
 class COMPOSITOR_EXPORT Compositor
     : NON_EXPORTED_BASE(public cc::LayerTreeHostClient),
       public base::SupportsWeakPtr<Compositor> {
  public:
   Compositor(CompositorDelegate* delegate,
              gfx::AcceleratedWidget widget);
   virtual ~Compositor();
 
+  // Set up the compositor ContextFactory for a test environment. Unit tests
+  // that do not have a full content environment need to call this before
+  // initializing the Compositor.
+  // Some tests expect pixel output, and they should pass false for
+  // |allow_test_contexts|. Most unit tests should pass true. Once this has been
+  // called, the Initialize() and Terminate() methods should be used as normal.
+  static void InitializeContextFactoryForTests(bool allow_test_contexts);
+
   static void Initialize();
   static bool WasInitializedWithThread();
   static scoped_refptr<base::MessageLoopProxy> GetCompositorMessageLoop();
   static void Terminate();
 
   // Schedules a redraw of the layer tree associated with this compositor.
   void ScheduleDraw();
 
   // Sets the root of the layer tree drawn by this Compositor. The root layer
   // must have no parent. The compositor's root layer is reset if the root layer
@@ skipping 137 matching lines @@
   bool disable_schedule_composite_;
 
   CompositorLock* compositor_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_