Clean up ScopedVectorTest's LifeCycleObject.

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:
+  ~LifeCycleObject() {
+    observer_->OnLifeCycleDestroy(this);
+  }
+
+ private:
+  friend class LifeCycleWatcher;
+
   class Observer {
    public:
     virtual void OnLifeCycleConstruct(LifeCycleObject* o) = 0;
     virtual void OnLifeCycleDestroy(LifeCycleObject* o) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   explicit LifeCycleObject(Observer* observer)
       : observer_(observer) {
     observer_->OnLifeCycleConstruct(this);
   }
 
-  ~LifeCycleObject() {
-    observer_->OnLifeCycleDestroy(this);
-  }
-
- private:
   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,
@@ skipping 62 matching lines @@
 }
 
 TEST(ScopedVectorTest, Clear) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
   scoped_vector.push_back(watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   scoped_vector.clear();
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
-  EXPECT_EQ(static_cast<size_t>(0), scoped_vector.size());
+  EXPECT_TRUE(scoped_vector.empty());

[gavinp, 2012/11/24 14:27:18]

And actually, no need for any cast at all here.

 }
 
 TEST(ScopedVectorTest, WeakClear) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
-  scoped_ptr<LifeCycleObject> object(watcher.NewLifeCycleObject());
-  scoped_vector.push_back(object.get());
+  scoped_vector.push_back(watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   scoped_vector.weak_clear();
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
-  EXPECT_EQ(static_cast<size_t>(0), scoped_vector.size());
+  EXPECT_TRUE(scoped_vector.empty());
 }
 
 TEST(ScopedVectorTest, Scope) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   {
     ScopedVector<LifeCycleObject> scoped_vector;
     scoped_vector.push_back(watcher.NewLifeCycleObject());
     EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   }
@@ skipping 93 matching lines @@
   for(LifeCycleWatcher* it = watchers; it != watchers + 1; ++it)
     EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state());
   for(LifeCycleWatcher* it = watchers + 1; it != watchers + 3; ++it)
     EXPECT_EQ(LC_DESTROYED, it->life_cycle_state());
   for(LifeCycleWatcher* it = watchers + 3; it != watchers + arraysize(watchers);
       ++it)
     EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state());
 }
 
 }  // namespace