Added more constructors to CallbackLayerAnimationObserver.

ui/compositor/callback_layer_animation_observer_unittest.cc

 // 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.
 
 #include "ui/compositor/callback_layer_animation_observer.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 136 matching lines @@
 
 // A test specific CallbackLayerAnimationObserver that will set a bool when
 // destroyed.
 class TestCallbackLayerAnimationObserver
     : public CallbackLayerAnimationObserver {
  public:
   TestCallbackLayerAnimationObserver(
       AnimationStartedCallback animation_started_callback,
       AnimationEndedCallback animation_ended_callback,
       bool* destroyed);
+
+  TestCallbackLayerAnimationObserver(
+      AnimationStartedCallback animation_started_callback,
+      bool should_delete_observer,
+      bool* destroyed);
+
+  TestCallbackLayerAnimationObserver(
+      AnimationEndedCallback animation_ended_callback,
+      bool* destroyed);
+
   ~TestCallbackLayerAnimationObserver() override;
 
  private:
   bool* destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCallbackLayerAnimationObserver);
 };
 
 TestCallbackLayerAnimationObserver::TestCallbackLayerAnimationObserver(
     AnimationStartedCallback animation_started_callback,
     AnimationEndedCallback animation_ended_callback,
     bool* destroyed)
     : CallbackLayerAnimationObserver(animation_started_callback,
                                      animation_ended_callback),
       destroyed_(destroyed) {
-  (*destroyed_) = false;
+  if (destroyed_)
+    (*destroyed_) = false;
+}
+
+TestCallbackLayerAnimationObserver::TestCallbackLayerAnimationObserver(
+    AnimationStartedCallback animation_started_callback,
+    bool should_delete_observer,
+    bool* destroyed)
+    : CallbackLayerAnimationObserver(animation_started_callback,
+                                     should_delete_observer),
+      destroyed_(destroyed) {
+  if (destroyed_)
+    (*destroyed_) = false;
+}
+
+TestCallbackLayerAnimationObserver::TestCallbackLayerAnimationObserver(
+    AnimationEndedCallback animation_ended_callback,
+    bool* destroyed)
+    : CallbackLayerAnimationObserver(animation_ended_callback),
+      destroyed_(destroyed) {
+  if (destroyed_)
+    (*destroyed_) = false;
 }
 
 TestCallbackLayerAnimationObserver::~TestCallbackLayerAnimationObserver() {
-  (*destroyed_) = true;
+  if (destroyed_)
+    (*destroyed_) = true;
 }
 
 class CallbackLayerAnimationObserverTest : public testing::Test {
  public:
   CallbackLayerAnimationObserverTest();
   ~CallbackLayerAnimationObserverTest() override;
 
  protected:
   // Creates a LayerAnimationSequence.  The lifetime of the sequence will be
   // managed by this.
@@ skipping 30 matching lines @@
   observer_.reset();
 }
 
 LayerAnimationSequence*
 CallbackLayerAnimationObserverTest::CreateLayerAnimationSequence() {
   LayerAnimationSequence* sequence = new LayerAnimationSequence();
   sequences_.push_back(sequence);
   return sequence;
 }
 
-TEST_F(CallbackLayerAnimationObserverTest, VerifyInitialState) {
-  EXPECT_FALSE(observer_->active());
-  EXPECT_EQ(0, observer_->aborted_count());
-  EXPECT_EQ(0, observer_->successful_count());
+TEST(CallbackLayerAnimationObserverDestructionTest, VerifyFalseAutoDelete) {
+  TestCallbacks callbacks;
+  callbacks.set_should_delete_observer_on_animations_ended(false);
 
-  EXPECT_FALSE(callbacks_->animations_started());
-  EXPECT_FALSE(callbacks_->animations_ended());
+  bool is_destroyed = false;
+
+  TestCallbackLayerAnimationObserver* observer =
+      new TestCallbackLayerAnimationObserver(
+          base::Bind(&TestCallbacks::AnimationsStarted,
+                     base::Unretained(&callbacks)),
+          false, &is_destroyed);
+  observer->SetActive();
+
+  EXPECT_FALSE(is_destroyed);
+  delete observer;
+}
+
+TEST(CallbackLayerAnimationObserverDestructionTest, VerifyTrueAutoDelete) {
+  TestCallbacks callbacks;
+  callbacks.set_should_delete_observer_on_animations_ended(false);
+
+  bool is_destroyed = false;
+
+  TestCallbackLayerAnimationObserver* observer =
+      new TestCallbackLayerAnimationObserver(
+          base::Bind(&TestCallbacks::AnimationsStarted,
+                     base::Unretained(&callbacks)),
+          true, &is_destroyed);
+  observer->SetActive();
+
+  EXPECT_TRUE(is_destroyed);
 }
 
 TEST(CallbackLayerAnimationObserverDestructionTest,
      AnimationEndedReturnsFalse) {
   TestCallbacks callbacks;
   callbacks.set_should_delete_observer_on_animations_ended(false);
 
   bool is_destroyed = false;
 
   TestCallbackLayerAnimationObserver* observer =
@@ skipping 20 matching lines @@
           base::Bind(&TestCallbacks::AnimationsStarted,
                      base::Unretained(&callbacks)),
           base::Bind(&TestCallbacks::AnimationsEnded,
                      base::Unretained(&callbacks)),
           &is_destroyed);
   observer->SetActive();
 
   EXPECT_TRUE(is_destroyed);
 }
 
+TEST_F(CallbackLayerAnimationObserverTest, VerifyInitialState) {
+  EXPECT_FALSE(observer_->active());
+  EXPECT_EQ(0, observer_->aborted_count());
+  EXPECT_EQ(0, observer_->successful_count());
+
+  EXPECT_FALSE(callbacks_->animations_started());
+  EXPECT_FALSE(callbacks_->animations_ended());
+}
+
 // Verifies that the CallbackLayerAnimationObserver is robust to explicit
 // deletes caused as a side effect of calling the AnimationsStartedCallback()
 // when there are no animation sequences attached. This test also guards against
 // heap-use-after-free errors.
 TEST_F(
     CallbackLayerAnimationObserverTest,
     ExplicitlyDeleteObserverInAnimationStartedCallbackWithNoSequencesAttached) {
   TestCallbacksThatExplicitlyDeletesObserver callbacks;
   callbacks.set_should_delete_observer_on_animations_ended(true);
 
@@ skipping 229 matching lines @@
   observer_->OnLayerAnimationEnded(sequence_4);
 
   EXPECT_FALSE(observer_->active());
   EXPECT_TRUE(callbacks_->animations_started());
   EXPECT_TRUE(callbacks_->animations_ended());
   EXPECT_EQ(4, observer_->successful_count());
 }
 
 }  // namespace test
 }  // namespace ui