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

cc/gl_renderer_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/gl_renderer.h"
 
 #include "cc/draw_quad.h"
 #include "cc/prioritized_texture_manager.h"
 #include "cc/resource_provider.h"
 #include "cc/settings.h"
+#include "cc/single_thread_proxy.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace WebKit;
@@ skipping 12 matching lines @@
     {
         if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_set_visibility GL_CHROMIUM_gpu_memory_manager GL_CHROMIUM_discard_framebuffer");
         return WebString();
     }
 
     // Methods added for test.
     int frameCount() { return m_frame; }
     void setMemoryAllocation(WebGraphicsMemoryAllocation allocation)
     {
+        DCHECK(Proxy::isImplThread());
+        // In single threaded mode we expect this callback on main thread.
+        DebugScopedSetMainThread main;
         m_memoryAllocationChangedCallback->onMemoryAllocationChanged(allocation);
     }
 
 private:
     int m_frame;
     WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* m_memoryAllocationChangedCallback;
 };
 
 class FakeRendererClient : public RendererClient {
 public:
@@ skipping 11 matching lines @@
     }
 
     // RendererClient methods.
     virtual const gfx::Size& deviceViewportSize() const OVERRIDE { static gfx::Size fakeSize(1, 1); return fakeSize; }
     virtual const LayerTreeSettings& settings() const OVERRIDE { static LayerTreeSettings fakeSettings; return fakeSettings; }
     virtual void didLoseContext() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { m_setFullRootLayerDamageCount++; }
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { m_memoryAllocationLimitBytes = policy.bytesLimitWhenVisible; }
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { if (m_lastCallWasSetVisibility) *m_lastCallWasSetVisibility = false; }
-    virtual bool hasImplThread() const OVERRIDE { return false; }
 
     // Methods added for test.
     int setFullRootLayerDamageCount() const { return m_setFullRootLayerDamageCount; }
     void setLastCallWasSetVisibilityPointer(bool* lastCallWasSetVisibility) { m_lastCallWasSetVisibility = lastCallWasSetVisibility; }
 
     RenderPass* rootRenderPass() { return m_renderPassesInDrawOrder.back(); }
     const RenderPassList& renderPassesInDrawOrder() const { return m_renderPassesInDrawOrder; }
     const RenderPassIdHashMap& renderPasses() const { return m_renderPasses; }
 
     size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
 
 private:
     int m_setFullRootLayerDamageCount;
     bool* m_lastCallWasSetVisibility;
+    DebugScopedSetImplThread m_implThread;
     scoped_ptr<LayerImpl> m_rootLayer;
     RenderPassList m_renderPassesInDrawOrder;
     RenderPassIdHashMap m_renderPasses;
     size_t m_memoryAllocationLimitBytes;
 };
 
 class FakeRendererGL : public GLRenderer {
 public:
     FakeRendererGL(RendererClient* client, ResourceProvider* resourceProvider) : GLRenderer(client, resourceProvider) { }
 
@@ skipping 372 matching lines @@
     // process, after glFlush is called, and after the RendererClient's enforceManagedMemoryPolicy
     // is called. Plumb this tracking between both the RenderClient and the Context by giving
     // them both a pointer to a variable on the stack.
     context->setLastCallWasSetVisibilityPointer(&lastCallWasSetVisiblity);
     mockClient.setLastCallWasSetVisibilityPointer(&lastCallWasSetVisiblity);
     renderer.setVisible(true);
     renderer.drawFrame(mockClient.renderPassesInDrawOrder(), mockClient.renderPasses());
     renderer.setVisible(false);
     EXPECT_TRUE(lastCallWasSetVisiblity);
 }