cc: Chromify TimeSource, DelayBasedTimeSource and test

cc/trees/layer_tree_host_impl.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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 65 matching lines @@
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
         new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl,
                                                time_source));
   }
   virtual ~LayerTreeHostImplTimeSourceAdapter() {
-    time_source_->setClient(NULL);
-    time_source_->setActive(false);
+    time_source_->SetClient(NULL);
+    time_source_->SetActive(false);
   }
 
-  virtual void onTimerTick() OVERRIDE {
+  virtual void OnTimerTick() OVERRIDE {
     // In single threaded mode we attempt to simulate changing the current
     // thread by maintaining a fake thread id. When we switch from one
     // thread to another, we construct DebugScopedSetXXXThread objects that
     // update the thread id. This lets DCHECKS that ensure we're on the
     // right thread to work correctly in single threaded mode. The problem
     // here is that the timer tasks are run via the message loop, and when
     // they run, we've had no chance to construct a DebugScopedSetXXXThread
     // object. The result is that we report that we're running on the main
     // thread. In multi-threaded mode, this timer is run on the compositor
     // thread, so to keep this consistent in single-threaded mode, we'll
     // construct a DebugScopedSetImplThread object. There is no need to do
     // this in multi-threaded mode since the real thread id's will be
     // correct. In fact, setting fake thread id's interferes with the real
     // thread id's and causes breakage.
     scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
     if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
       set_impl_thread.reset(
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
     layer_tree_host_impl_->Animate(base::TimeTicks::Now(), base::Time::Now());
     layer_tree_host_impl_->BeginNextFrame();
   }
 
   void SetActive(bool active) {
-    if (active != time_source_->active())
-      time_source_->setActive(active);
+    if (active != time_source_->Active())
+      time_source_->SetActive(active);
   }
 
  private:
   LayerTreeHostImplTimeSourceAdapter(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source)
       : layer_tree_host_impl_(layer_tree_host_impl),
         time_source_(time_source) {
-    time_source_->setClient(this);
+    time_source_->SetClient(this);
   }
 
   LayerTreeHostImpl* layer_tree_host_impl_;
   scoped_refptr<DelayBasedTimeSource> time_source_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
 };
 
 LayerTreeHostImpl::FrameData::FrameData()
     : contains_incomplete_tile(false) {}
@@ skipping 519 matching lines @@
 
   return draw_frame;
 }
 
 void LayerTreeHostImpl::SetBackgroundTickingEnabled(bool enabled) {
   // Lazily create the time_source adapter so that we can vary the interval for
   // testing.
   if (!time_source_client_adapter_) {
     time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
         this,
-        DelayBasedTimeSource::create(LowFrequencyAnimationInterval(),
+        DelayBasedTimeSource::Create(LowFrequencyAnimationInterval(),
                                      proxy_->CurrentThread()));
   }
 
   time_source_client_adapter_->SetActive(enabled);
 }
 
 static inline RenderPass* FindRenderPassById(
     RenderPass::Id render_pass_id,
     const LayerTreeHostImpl::FrameData& frame) {
   RenderPassIdHashMap::const_iterator it =
@@ skipping 1289 matching lines @@
     tile_manager_->SetRecordRenderingStats(debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
                                       int commit_number) {
   DCHECK(debug_state_.continuous_painting);
   paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
 }
 
 }  // namespace cc