Added more constructors to CallbackLayerAnimationObserver.

ui/compositor/callback_layer_animation_observer.h

 // Copyright 2015 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 UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_
 #define UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_
 
 #include "base/callback.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/compositor/layer_animation_observer.h"
@@ skipping 51 matching lines @@
   // been started.
   typedef base::Callback<void(const CallbackLayerAnimationObserver&)>
       AnimationStartedCallback;
 
   // The Callback type that will be invoked when all animation sequences have
   // finished. |this| will be destroyed after invoking the Callback if it
   // returns true.
   typedef base::Callback<bool(const CallbackLayerAnimationObserver&)>
       AnimationEndedCallback;
 
+  // A dummy no-op AnimationStartedCallback.
+  static void DummyAnimationStartedCallback(
+      const CallbackLayerAnimationObserver&);
+
+  // A dummy no-op AnimationEndedCallback that will return
+  // |should_delete_observer|.
+  //
+  // Example usage:
+  //
+  //    ui::CallbackLayerAnimationObserver* animation_observer =
+  //        new ui::CallbackLayerAnimationObserver(
+  //            base::Bind(&ui::CallbackLayerAnimationObserver::
+  //                DummyAnimationStartedCallback),
+  //            base::Bind(&ui::CallbackLayerAnimationObserver::
+  //                DummyAnimationEndedCallback, false));
+  static bool DummyAnimationEndedCallback(
+      bool should_delete_observer,
+      const CallbackLayerAnimationObserver&);
+
+  // Create an instance that will invoke the |animation_started_callback| when
+  // the animation has started and the |animation_ended_callback| when the
+  // animation has ended.
   CallbackLayerAnimationObserver(
       AnimationStartedCallback animation_started_callback,
       AnimationEndedCallback animation_ended_callback);
+
+  // Create an instance that will invoke the |animation_started_callback| when
+  // the animation has started and will delete |this| when the animations have
+  // ended if |should_delete_observer| is true.
+  CallbackLayerAnimationObserver(
+      AnimationStartedCallback animation_started_callback,
+      bool should_delete_observer);
+
+  // Create an instance that will invoke the |animation_ended_callback| when the
+  // animations have ended.
+  explicit CallbackLayerAnimationObserver(
+      AnimationEndedCallback animation_ended_callback);
+
   ~CallbackLayerAnimationObserver() override;
 
   bool active() const { return active_; }
 
   // The callbacks will not be invoked until SetActive() has been called. This
   // allows each sequence to be attached before checking if the sequences have
   // finished.
   void SetActive();
 
   int aborted_count() const { return aborted_count_; }
@@ skipping 16 matching lines @@
 
   // Checks if all attached sequences have been started and invokes
   // |animation_started_callback_| if |active_| is true.
   void CheckAllSequencesStarted();
 
   // Checks if all attached sequences have completed and invokes
   // |animation_ended_callback_| if |active_| is true.
   void CheckAllSequencesCompleted();
 
   // Allows the callbacks to be invoked when true.
-  bool active_;
+  bool active_ = false;
 
   // The total number of animation sequences that have been attached.
-  int attached_sequence_count_;
+  int attached_sequence_count_ = 0;
 
   // The total number of animation sequences that have been detached.
-  int detached_sequence_count_;
+  int detached_sequence_count_ = 0;
 
   // The number of animation sequences that have been started.
-  int started_count_;
+  int started_count_ = 0;
 
   // The number of animation sequences that were aborted.
-  int aborted_count_;
+  int aborted_count_ = 0;
 
   // The number of animation sequences that completed successfully.
-  int successful_count_;
+  int successful_count_ = 0;
 
   // The callback to invoke once all the animation sequences have been started.
   AnimationStartedCallback animation_started_callback_;
 
   // The callback to invoke once all the animation sequences have finished.
   AnimationEndedCallback animation_ended_callback_;
 
   // Set to true in the destructor (if non-NULL). Used to detect deletion while
   // calling out.
-  bool* destroyed_;
+  bool* destroyed_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackLayerAnimationObserver);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_