Switch some Singletons to use LeakySingleton.

base/singleton_unittest.cc

 // Copyright (c) 2006-2008 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/at_exit.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 26 matching lines @@
 
 struct LeakTrait : public CallbackTrait {
   static const bool kRegisterAtExit = false;
 };
 
 int* SingletonInt1() {
   return Singleton<int>::get();
 }
 
 int* SingletonInt2() {
+  typedef int FooType;
   // Force to use a different singleton than SingletonInt1.
-  return Singleton<int, DefaultSingletonTraits<int> >::get();
+  return Singleton<FooType>::get();
 }
 
 class DummyDifferentiatingClass {
 };
 
 int* SingletonInt3() {
   // Force to use a different singleton than SingletonInt1 and SingletonInt2.
   // Note that any type can be used; int, float, std::wstring...
   return Singleton<int, DefaultSingletonTraits<int>,
                    DummyDifferentiatingClass>::get();
@@ skipping 68 matching lines @@
   int* singleton_int_4;
   int* singleton_int_5;
   CallbackFunc* leaky_singleton;
 
   {
     base::ShadowingAtExitManager sem;
     {
       singleton_int_1 = SingletonInt1();
     }
     // Ensure POD type initialization.
-    EXPECT_EQ(*singleton_int_1, 0);
+    EXPECT_EQ(0, *singleton_int_1);
     *singleton_int_1 = 1;
 
     EXPECT_EQ(singleton_int_1, SingletonInt1());
-    EXPECT_EQ(*singleton_int_1, 1);
+    EXPECT_EQ(1, *singleton_int_1);
 
     {
       singleton_int_2 = SingletonInt2();
     }
     // Same instance that 1.
-    EXPECT_EQ(*singleton_int_2, 1);
+    EXPECT_EQ(1, *singleton_int_2);
     EXPECT_EQ(singleton_int_1, singleton_int_2);
 
     {
       singleton_int_3 = SingletonInt3();
     }
     // Different instance than 1 and 2.
-    EXPECT_EQ(*singleton_int_3, 0);
+    EXPECT_EQ(0, *singleton_int_3);
     EXPECT_NE(singleton_int_1, singleton_int_3);
     *singleton_int_3 = 3;
-    EXPECT_EQ(*singleton_int_1, 1);
-    EXPECT_EQ(*singleton_int_2, 1);
+    EXPECT_EQ(1, *singleton_int_1);
+    EXPECT_EQ(1, *singleton_int_2);
 
     {
       singleton_int_4 = SingletonInt4();
     }
     // Use a lock for creation. Not really tested at length.
     EXPECT_EQ(*singleton_int_4, 0);
     *singleton_int_4 = 4;
     EXPECT_NE(singleton_int_1, singleton_int_4);
     EXPECT_NE(singleton_int_3, singleton_int_4);
 
@@ skipping 26 matching lines @@
       EXPECT_EQ(*singleton_int_1, 0);
     }
     {
       singleton_int_5 = SingletonInt5();
       EXPECT_EQ(*singleton_int_5, 5);
     }
   }
   // The leaky singleton shouldn't leak since SingletonLeak has not been called.
   VerifiesCallbacksNotCalled();
 }