Impl thread smooth scrolling.

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "cc/animation/animation_delegate.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/animation/layer_animation_value_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/layers/layer_position_constraint.h"
@@ skipping 34 matching lines @@
 struct AppendQuadsData;
 
 enum DrawMode {
   DRAW_MODE_NONE,
   DRAW_MODE_HARDWARE,
   DRAW_MODE_SOFTWARE,
   DRAW_MODE_RESOURCELESS_SOFTWARE
 };
 
 class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
-                            public LayerAnimationValueProvider {
+                            public LayerAnimationValueProvider,
+                            public AnimationDelegate {
  public:
   // Allows for the ownership of the total scroll offset to be delegated outside
   // of the layer.
   class ScrollOffsetDelegate {
    public:
     virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_value) = 0;
     virtual gfx::Vector2dF GetTotalScrollOffset() = 0;
     virtual bool IsExternalFlingActive() const = 0;
   };
 
@@ skipping 16 matching lines @@
 
   // LayerAnimationValueObserver implementation.
   virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE;
   virtual void OnOpacityAnimated(float opacity) OVERRIDE;
   virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
   virtual void OnScrollOffsetAnimated(
       const gfx::Vector2dF& scroll_offset) OVERRIDE;
   virtual void OnAnimationWaitingForDeletion() OVERRIDE;
   virtual bool IsActive() const OVERRIDE;
 
+  // AnimationDelegate implementation.
+  virtual void NotifyAnimationStarted(
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE{};
+  virtual void NotifyAnimationFinished(
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE;
+
   // Tree structure.
   LayerImpl* parent() { return parent_; }
   const LayerImpl* parent() const { return parent_; }
   const OwnedLayerImplList& children() const { return children_; }
   OwnedLayerImplList& children() { return children_; }
   LayerImpl* child_at(size_t index) const { return children_[index]; }
   void AddChild(scoped_ptr<LayerImpl> child);
   scoped_ptr<LayerImpl> RemoveChild(LayerImpl* child);
   void SetParent(LayerImpl* parent);
 
@@ skipping 575 matching lines @@
   DrawProperties<LayerImpl> draw_properties_;
 
   scoped_refptr<base::debug::ConvertableToTraceFormat> debug_info_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_