cc: Chromify the LayerTreeHostImpl class.

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"
@@ skipping 20 matching lines @@
 
 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)
+bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*, LayerTreeHostImpl::FrameData*, bool)
 {
     return true;
 }
 
 bool TestHooks::canActivatePendingTree()
 {
     return true;
 }
 
 scoped_ptr<OutputSurface> TestHooks::createOutputSurface()
 {
     return createFakeOutputSurface();
 }
 
 scoped_refptr<cc::ContextProvider> TestHooks::OffscreenContextProviderForMainThread()
 {
     return m_fakeClient->OffscreenContextProviderForMainThread();
 }
 
 scoped_refptr<cc::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()
+void MockLayerTreeHostImpl::BeginCommit()
 {
-    LayerTreeHostImpl::beginCommit();
+    LayerTreeHostImpl::BeginCommit();
     m_testHooks->beginCommitOnThread(this);
 }
 
-void MockLayerTreeHostImpl::commitComplete()
+void MockLayerTreeHostImpl::CommitComplete()
 {
-    LayerTreeHostImpl::commitComplete();
+    LayerTreeHostImpl::CommitComplete();
     m_testHooks->commitCompleteOnThread(this);
 
-    if (!Settings().implSidePainting)
+    if (!settings().implSidePainting)
         m_testHooks->treeActivatedOnThread(this);
 
 }
 
-bool MockLayerTreeHostImpl::prepareToDraw(FrameData& frame)
+bool MockLayerTreeHostImpl::PrepareToDraw(FrameData* frame)
 {
-    bool result = LayerTreeHostImpl::prepareToDraw(frame);
+    bool result = LayerTreeHostImpl::PrepareToDraw(frame);
     if (!m_testHooks->prepareToDrawOnThread(this, frame, result))
         result = false;
     return result;
 }
 
-void MockLayerTreeHostImpl::drawLayers(FrameData& frame)
+void MockLayerTreeHostImpl::DrawLayers(FrameData* frame)
 {
-    LayerTreeHostImpl::drawLayers(frame);
+    LayerTreeHostImpl::DrawLayers(frame);
     m_testHooks->drawLayersOnThread(this);
 }
 
-bool MockLayerTreeHostImpl::activatePendingTreeIfNeeded()
+bool MockLayerTreeHostImpl::ActivatePendingTreeIfNeeded()
 {
-    if (!pendingTree())
+    if (!pending_tree())
         return false;
 
     if (!m_testHooks->canActivatePendingTree())
         return false;
 
-    bool activated = LayerTreeHostImpl::activatePendingTreeIfNeeded();
+    bool activated = LayerTreeHostImpl::ActivatePendingTreeIfNeeded();
     if (activated)
         m_testHooks->treeActivatedOnThread(this);
     return activated;
 }
 
-bool MockLayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
+bool MockLayerTreeHostImpl::InitializeRenderer(scoped_ptr<OutputSurface> outputSurface)
 {
-    bool success = LayerTreeHostImpl::initializeRenderer(outputSurface.Pass());
+    bool success = LayerTreeHostImpl::InitializeRenderer(outputSurface.Pass());
     m_testHooks->initializedRendererOnThread(this, success);
     return success;
 }
 
-void MockLayerTreeHostImpl::setVisible(bool visible)
+void MockLayerTreeHostImpl::SetVisible(bool visible)
 {
-    LayerTreeHostImpl::setVisible(visible);
+    LayerTreeHostImpl::SetVisible(visible);
     m_testHooks->didSetVisibleOnImplTree(this, visible);
 }
 
-void MockLayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
+void MockLayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     m_testHooks->willAnimateLayers(this, monotonicTime);
-    LayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
+    LayerTreeHostImpl::AnimateLayers(monotonicTime, wallClockTime);
     m_testHooks->animateLayers(this, monotonicTime);
 }
 
-void MockLayerTreeHostImpl::updateAnimationState()
+void MockLayerTreeHostImpl::UpdateAnimationState()
 {
-    LayerTreeHostImpl::updateAnimationState();
+    LayerTreeHostImpl::UpdateAnimationState();
     bool hasUnfinishedAnimation = false;
-    AnimationRegistrar::AnimationControllerMap::const_iterator iter = activeAnimationControllers().begin();
-    for (; iter != activeAnimationControllers().end(); ++iter) {
+    AnimationRegistrar::AnimationControllerMap::const_iterator iter = active_animation_controllers().begin();
+    for (; iter != active_animation_controllers().end(); ++iter) {
         if (iter->second->HasActiveAnimation()) {
             hasUnfinishedAnimation = true;
             break;
         }
     }
     m_testHooks->updateAnimationState(this, hasUnfinishedAnimation);
 }
 
-base::TimeDelta MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
+base::TimeDelta MockLayerTreeHostImpl::LowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromMilliseconds(16);
 }
 
 MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : LayerTreeHostImpl(settings, client, proxy)
     , m_testHooks(testHooks)
 {
 }
 
@@ skipping 354 matching lines @@
     ASSERT_FALSE(m_layerTreeHost.get());
     m_client.reset();
     if (m_timedOut) {
         FAIL() << "Test timed out";
         return;
     }
     afterTest();
 }
 
 }  // namespace cc