A speculative Revert for r165872 - Remove static thread pointers from CC, attempt 2

cc/delegated_renderer_layer_impl_unittest.cc

 // Copyright 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.
 
 #include "config.h"
 
 #include "cc/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/scoped_ptr_vector.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/solid_color_layer_impl.h"
-#include "cc/test/fake_proxy.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/mock_quad_culler.h"
 #include "cc/test/render_pass_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::FakeWebCompositorOutputSurface;
 using WebKit::FakeWebGraphicsContext3D;
 using WebKit::WebTransformationMatrix;
 
 using namespace cc;
 using namespace WebKitTests;
 
 namespace {
 
 class DelegatedRendererLayerImplTest : public testing::Test, public LayerTreeHostImplClient {
 public:
     DelegatedRendererLayerImplTest()
-        : m_proxy(scoped_ptr<Thread>(NULL))
-        , m_alwaysImplThreadAndMainThreadBlocked(&m_proxy)
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
 
-        m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+        m_hostImpl = LayerTreeHostImpl::create(settings, this);
         m_hostImpl->initializeRenderer(createContext());
         m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     // LayerTreeHostImplClient implementation.
     virtual void didLoseContextOnImplThread() OVERRIDE { }
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(base::TimeTicks, base::TimeDelta) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool) OVERRIDE { }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return true; }
     virtual void sendManagedMemoryStats() OVERRIDE { }
 
 protected:
     scoped_ptr<GraphicsContext> createContext()
     {
         return FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3D)).PassAs<GraphicsContext>();
     }
 
-    FakeProxy m_proxy;
-    DebugScopedSetImplThreadAndMainThreadBlocked m_alwaysImplThreadAndMainThreadBlocked;
+    DebugScopedSetImplThread m_alwaysImplThread;
+    DebugScopedSetMainThreadBlocked m_alwaysMainThreadBlocked;
+
     scoped_ptr<LayerTreeHostImpl> m_hostImpl;
 };
 
 static TestRenderPass* addRenderPass(ScopedPtrVector<RenderPass>& passList, RenderPass::Id id, gfx::Rect outputRect, WebTransformationMatrix rootTransform)
 {
     scoped_ptr<TestRenderPass> pass(TestRenderPass::create(id, outputRect, rootTransform));
     TestRenderPass* saved = pass.get();
     passList.append(pass.PassAs<RenderPass>());
     return saved;
 }
@@ skipping 370 matching lines @@
     EXPECT_EQ(sharedState, quadList[3]->sharedQuadState());
 
     // The state should be transformed only once.
     EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clippedRectInTarget);
     WebTransformationMatrix expected;
     expected.translate(30, 30);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->quadTransform);
 }
 
 } // namespace