Move TokenCacheService away from listening for Signin notifications.

chrome/browser/extensions/token_cache/token_cache_service_unittest.cc

 // Copyright (c) 2013 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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/time/time.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/token_cache/token_cache_service.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
+#include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace extensions {
 
 class TokenCacheTest : public testing::Test {
  public:
-  TokenCacheTest() : cache_(NULL) {}
+  TokenCacheTest() : cache_(&profile_) {}
   virtual ~TokenCacheTest() {}
 
   size_t CacheSize() {
     return cache_.token_cache_.size();
   }
 
   bool HasMatch(const std::string& token_name) {
     return cache_.RetrieveToken(token_name) != std::string();
   }
 
   void InsertExpiredToken(const std::string& token_name,
                           const std::string& token_value) {
     EXPECT_TRUE(!HasMatch(token_name));
 
     // Compute a time value for yesterday
     Time now = Time::Now();
     TimeDelta one_day = one_day.FromDays(1);
     Time yesterday = now - one_day;
 
     TokenCacheService::TokenCacheData token_data;
     token_data.token = token_value;
     token_data.expiration_time = yesterday;
 
     cache_.token_cache_[token_name] = token_data;
   }
 
  protected:
+  TestingProfile profile_;
   TokenCacheService cache_;
 };
 
 TEST_F(TokenCacheTest, SaveTokenTest) {
   TimeDelta zero;
   cache_.StoreToken("foo", "bar", zero);
 
   EXPECT_EQ(1U, CacheSize());
   EXPECT_TRUE(HasMatch("foo"));
 }
@@ skipping 20 matching lines @@
   cache_.StoreToken("Chopin", "Military", zero);
 
   found_token = cache_.RetrieveToken("Chopin");
   EXPECT_EQ("Military", found_token);
   EXPECT_EQ(1U, CacheSize());
 }
 
 TEST_F(TokenCacheTest, SignoutTest) {
   TimeDelta zero;
   cache_.StoreToken("foo", "bar", zero);
-  content::Source<Profile> stub_source(NULL);
-  content::NotificationDetails stub_details;
 
   EXPECT_EQ(1U, CacheSize());
   EXPECT_TRUE(HasMatch("foo"));
 
-  cache_.Observe(chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
-                 stub_source, stub_details);
+  cache_.GoogleSignedOut("foo");
 
   EXPECT_EQ(0U, CacheSize());
   EXPECT_FALSE(HasMatch("foo"));
 }
 
 TEST_F(TokenCacheTest, TokenExpireTest) {
   // Use the fact that we are friends to insert an expired token.
   InsertExpiredToken("foo", "bar");
 
   EXPECT_EQ(1U, CacheSize());
 
   // If we attempt to find the token, the attempt should fail.
   EXPECT_FALSE(HasMatch("foo"));
   EXPECT_EQ(0U, CacheSize());
 }
 
 } // namespace extensions