cc: Route offscreen context creation for compositor to the browser.

cc/test/layer_tree_test_common.cc

 // Copyright 2011 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.
 
 #include "cc/test/layer_tree_test_common.h"
 
 #include "cc/animation.h"
 #include "cc/animation_registrar.h"
 #include "cc/content_layer.h"
 #include "cc/input_handler.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/thread_impl.h"
 #include "cc/test/animation_test_common.h"
+#include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperation.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
 #include "ui/gfx/size_conversions.h"
 
 using namespace WebKit;
 
 namespace cc {
 
+TestHooks::TestHooks()
+{
+  bool useSoftwareRendering = false;
+  bool useDelegatingRenderer = false;
+  m_fakeClient.reset(new FakeLayerImplTreeHostClient(useSoftwareRendering, useDelegatingRenderer));
+}
+
+TestHooks::~TestHooks() { }
+
 bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool)
 {
     return true;
 }
 
 bool TestHooks::canActivatePendingTree()
 {
     return true;
 }
 
 scoped_ptr<OutputSurface> TestHooks::createOutputSurface()
 {
     return createFakeOutputSurface();
 }
 
+scoped_refptr<ui::ContextProvider> TestHooks::OffscreenContextProviderForMainThread()
+{
+    return m_fakeClient->OffscreenContextProviderForMainThread();
+}
+
+scoped_refptr<ui::ContextProvider> TestHooks::OffscreenContextProviderForCompositorThread()
+{
+    return m_fakeClient->OffscreenContextProviderForCompositorThread();
+}
+
 scoped_ptr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
 {
     return make_scoped_ptr(new MockLayerTreeHostImpl(testHooks, settings, client, proxy));
 }
 
 void MockLayerTreeHostImpl::beginCommit()
 {
     LayerTreeHostImpl::beginCommit();
     m_testHooks->beginCommitOnThread(this);
 }
@@ skipping 135 matching lines @@
     virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE
     {
         return m_testHooks->createOutputSurface();
     }
 
     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
     {
         m_testHooks->didRecreateOutputSurface(succeeded);
     }
 
+    virtual void willRetryRecreateOutputSurface() OVERRIDE
+    {
+        m_testHooks->willRetryRecreateOutputSurface();
+    }
+
     virtual scoped_ptr<InputHandler> createInputHandler() OVERRIDE
     {
         return scoped_ptr<InputHandler>();
     }
 
     virtual void willCommit() OVERRIDE
     {
     }
 
     virtual void didCommit() OVERRIDE
     {
         m_testHooks->didCommit();
     }
 
     virtual void didCommitAndDrawFrame() OVERRIDE
     {
         m_testHooks->didCommitAndDrawFrame();
     }
 
     virtual void didCompleteSwapBuffers() OVERRIDE
     {
     }
 
     virtual void scheduleComposite() OVERRIDE
     {
         m_testHooks->scheduleComposite();
     }
 
+    virtual scoped_refptr<ui::ContextProvider> OffscreenContextProviderForMainThread() OVERRIDE
+    {
+        return m_testHooks->OffscreenContextProviderForMainThread();
+    }
+
+    virtual scoped_refptr<ui::ContextProvider> OffscreenContextProviderForCompositorThread() OVERRIDE
+    {
+        return m_testHooks->OffscreenContextProviderForCompositorThread();
+    }
+
 private:
     explicit ThreadedMockLayerTreeHostClient(TestHooks* testHooks) : m_testHooks(testHooks) { }
 
     TestHooks* m_testHooks;
 };
 
 ThreadedTest::ThreadedTest()
     : m_beginning(false)
     , m_endWhenBeginReturns(false)
     , m_timedOut(false)
@@ skipping 66 matching lines @@
 
     m_started = true;
     m_beginning = true;
     setupTree();
     m_layerTreeHost->setSurfaceReady();
     beginTest();
     m_beginning = false;
     if (m_endWhenBeginReturns)
         realEndTest();
 
-    LayerTreeHost::setNeedsFilterContext(false);
-
     // Allow commits to happen once beginTest() has had a chance to post tasks
     // so that those tasks will happen before the first commit.
     if (m_layerTreeHost)
         static_cast<MockLayerTreeHost*>(m_layerTreeHost.get())->setTestStarted(true);
 }
 
 void ThreadedTest::setupTree()
 {
     if (!m_layerTreeHost->rootLayer()) {
         scoped_refptr<Layer> rootLayer = Layer::create();
@@ skipping 110 matching lines @@
     ASSERT_FALSE(m_layerTreeHost.get());
     m_client.reset();
     if (m_timedOut) {
         FAIL() << "Test timed out";
         return;
     }
     afterTest();
 }
 
 }  // namespace cc