Fix LifeCycleWatcher in ScopedVectorTest to not be referenced after being destructed.

base/memory/scoped_vector_unittest.cc

 // Copyright (c) 2012 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 "base/memory/scoped_vector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // The LifeCycleObject notifies its Observer upon construction & destruction.
 class LifeCycleObject {
  public:
   class Observer {
    public:
     virtual void OnLifeCycleConstruct(LifeCycleObject* o) = 0;
     virtual void OnLifeCycleDestroy(LifeCycleObject* o) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   ~LifeCycleObject() {
-    observer_->OnLifeCycleDestroy(this);
+    if (observer_)
+      observer_->OnLifeCycleDestroy(this);
   }
 
  private:
   friend class LifeCycleWatcher;
 
   explicit LifeCycleObject(Observer* observer)
       : observer_(observer) {
     observer_->OnLifeCycleConstruct(this);
   }
 
+  void DisconnectObserver() {
+    observer_ = nullptr;
+  }
+
   Observer* observer_;
 
   DISALLOW_COPY_AND_ASSIGN(LifeCycleObject);
 };
 
 // The life cycle states we care about for the purposes of testing ScopedVector
 // against objects.
 enum LifeCycleState {
   LC_INITIAL,
   LC_CONSTRUCTED,
   LC_DESTROYED,
 };
 
 // Because we wish to watch the life cycle of an object being constructed and
 // destroyed, and further wish to test expectations against the state of that
 // object, we cannot save state in that object itself. Instead, we use this
 // pairing of the watcher, which observes the object and notifies of
 // construction & destruction. Since we also may be testing assumptions about
 // things not getting freed, this class also acts like a scoping object and
 // deletes the |constructed_life_cycle_object_|, if any when the
 // LifeCycleWatcher is destroyed. To keep this simple, the only expected state
 // changes are:
 //   INITIAL -> CONSTRUCTED -> DESTROYED.
 // Anything more complicated than that should start another test.
 class LifeCycleWatcher : public LifeCycleObject::Observer {
  public:
   LifeCycleWatcher() : life_cycle_state_(LC_INITIAL) {}
-  ~LifeCycleWatcher() override {}
+  ~LifeCycleWatcher() override {
+    // Stop watching the watched object. Without this, the object's destructor

[danakj, 2015/09/24 17:43:51]

Alternatively, you could just keep the watcher alive in the test this is causing
a problem for? Which test(s) are wrong here?

[Anand Mistry (off Chromium), 2015/09/24 21:56:27]

The two tests that fail are WeakClear and InsertRange. Both create watched
object thats aren't deleted by ScopedVector, so it's up to LifeCycleWatcher to
clean up at the end of the test.

+    // will call into OnLifeCycleDestroy when destructed, which happens after
+    // this destructor has finished running.
+    if (constructed_life_cycle_object_)
+      constructed_life_cycle_object_->DisconnectObserver();
+  }
 
   // Assert INITIAL -> CONSTRUCTED and no LifeCycleObject associated with this
   // LifeCycleWatcher.
   void OnLifeCycleConstruct(LifeCycleObject* object) override {
     ASSERT_EQ(LC_INITIAL, life_cycle_state_);
     ASSERT_EQ(NULL, constructed_life_cycle_object_.get());
     life_cycle_state_ = LC_CONSTRUCTED;
     constructed_life_cycle_object_.reset(object);
   }
 
@@ skipping 239 matching lines @@
   EXPECT_EQ(0, delete_counter);
   {
     ScopedVector<DeleteCounter> v;
     v.push_back(elem.Pass());
     EXPECT_EQ(0, delete_counter);
   }
   EXPECT_EQ(1, delete_counter);
 }
 
 }  // namespace