Add support for top level geolocation arbitrator, and access token persistenc...

chrome/browser/geolocation/network_location_provider_unittest.cc

 // Copyright (c) 2010 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 "chrome/browser/geolocation/network_location_provider.h"
 
 #include <map>
 
 #include "base/json/json_reader.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/values.h"
+#include "chrome/browser/geolocation/access_token_store.h"
 #include "chrome/browser/net/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const char kTestServerUrl[] = "https://www.geolocation.test/service";
 const char kTestHost[] = "myclienthost.test";
 }  // namespace
 
 // Stops the specified (nested) message loop when the listener is called back.
@@ skipping 15 matching lines @@
   virtual void MovementDetected(LocationProviderBase* provider) {
     EXPECT_EQ(client_message_loop_, MessageLoop::current());
     movement_provider_ = provider;
     client_message_loop_->Quit();
   }
   MessageLoop* client_message_loop_;
   LocationProviderBase* updated_provider_;
   LocationProviderBase* movement_provider_;
 };
 
-class FakeAccessTokenStore : public LocationProviderBase::AccessTokenStore {
+class FakeAccessTokenStore : public AccessTokenStore {
  public:
   FakeAccessTokenStore() : allow_set_(true) {}
 
   virtual bool SetAccessToken(const GURL& url,
                               const string16& access_token) {
     if (!allow_set_)
       return false;
     token_map_[url] = access_token;
     return true;
   }
   virtual bool GetAccessToken(const GURL& url, string16* access_token) {
     std::map<GURL, string16>::iterator item = token_map_.find(url);
     if (item == token_map_.end())
       return false;
     *access_token = item->second;
     return true;
   }
   bool allow_set_;
   std::map<GURL, string16> token_map_;
+
+ private:
+  ~FakeAccessTokenStore() {}
 };
 
 
 // A mock implementation of DeviceDataProviderImplBase for testing. Adapted from
 // http://gears.googlecode.com/svn/trunk/gears/geolocation/geolocation_test.cc
 template<typename DataType>
 class MockDeviceDataProviderImpl
     : public DeviceDataProviderImplBase<DataType> {
  public:
   // Factory method for use with DeviceDataProvider::SetFactory.
@@ skipping 47 matching lines @@
 
 template<typename DataType>
 MockDeviceDataProviderImpl<DataType>*
 MockDeviceDataProviderImpl<DataType>::instance_ = NULL;
 
 // Main test fixture
 class GeolocationNetworkProviderTest : public testing::Test {
  public:
   virtual void SetUp() {
     URLFetcher::set_factory(&url_fetcher_factory_);
+    access_token_store_ = new FakeAccessTokenStore;
   }
 
   virtual void TearDown() {
     WifiDataProvider::ResetFactory();
     RadioDataProvider::ResetFactory();
     URLFetcher::set_factory(NULL);
     base::LeakTracker<URLFetcher>::CheckForLeaks();
   }
 
   LocationProviderBase* CreateProvider() {
     return NewNetworkLocationProvider(
-        &access_token_store_,
+        access_token_store_.get(),
         NULL,  // No URLContextGetter needed, as using test urlfecther factory.
         test_server_url_,
         ASCIIToUTF16(kTestHost));
   }
 
  protected:
   GeolocationNetworkProviderTest() : test_server_url_(kTestServerUrl) {
     // TODO(joth): Really these should be in SetUp, not here, but they take no
     // effect on Mac OS Release builds if done there. I kid not. Figure out why.
     RadioDataProvider::SetFactory(
@@ skipping 89 matching lines @@
       EXPECT_EQ(expected->signal_to_noise, actual->signal_to_noise) << i;
       EXPECT_EQ(expected->ssid, actual->ssid) << i;
       ++expected;
       ++actual;
     }
     EXPECT_EQ(expected_access_token, access_token);
   }
 
   const GURL test_server_url_;
   MessageLoop main_message_loop_;
-  FakeAccessTokenStore  access_token_store_;
+  scoped_refptr<FakeAccessTokenStore> access_token_store_;
   TestURLFetcherFactory url_fetcher_factory_;
 };
 
 
 TEST_F(GeolocationNetworkProviderTest, CreateDestroy) {
   // Test fixture members were SetUp correctly.
   EXPECT_EQ(&main_message_loop_, MessageLoop::current());
   scoped_ptr<LocationProviderBase> provider(CreateProvider());
   EXPECT_TRUE(NULL != provider.get());
   provider.reset();
@@ skipping 41 matching lines @@
   const char* kNoFixNetworkResponse =
       "{"
       "  \"location\": null,"
       "  \"access_token\": \"" REFERENCE_ACCESS_TOKEN "\""
       "}";
   fetcher->delegate()->OnURLFetchComplete(
       fetcher, test_server_url_, URLRequestStatus(), 200,  // OK
       ResponseCookies(), kNoFixNetworkResponse);
 
   // This should have set the access token anyhow
-  EXPECT_EQ(1, static_cast<int>(access_token_store_.token_map_.size()));
+  EXPECT_EQ(1, static_cast<int>(access_token_store_->token_map_.size()));
   string16 token;
-  EXPECT_TRUE(access_token_store_.GetAccessToken(test_server_url_, &token));
+  EXPECT_TRUE(access_token_store_->GetAccessToken(test_server_url_, &token));
   EXPECT_EQ(REFERENCE_ACCESS_TOKEN, UTF16ToUTF8(token));
 
   Position position;
   provider->GetPosition(&position);
   EXPECT_FALSE(position.IsValidFix());
 
   // Now wifi data arrives
   const int kFirstScanAps = 6;
   MockDeviceDataProviderImpl<WifiData>::instance()->SetData(
       CreateReferenceWifiScanData(kFirstScanAps));  // Will notify listeners
@@ skipping 23 matching lines @@
   provider->GetPosition(&position);
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_EQ(30.1, position.altitude);
   EXPECT_EQ(1200.4, position.accuracy);
   EXPECT_EQ(10.6, position.altitude_accuracy);
   EXPECT_TRUE(position.is_valid_timestamp());
   EXPECT_TRUE(position.IsValidFix());
 
   // Token should still be in the store.
-  EXPECT_EQ(1, static_cast<int>(access_token_store_.token_map_.size()));
-  EXPECT_TRUE(access_token_store_.GetAccessToken(test_server_url_, &token));
+  EXPECT_EQ(1, static_cast<int>(access_token_store_->token_map_.size()));
+  EXPECT_TRUE(access_token_store_->GetAccessToken(test_server_url_, &token));
   EXPECT_EQ(REFERENCE_ACCESS_TOKEN, UTF16ToUTF8(token));
 
   // Wifi updated again, with one less AP. This is 'close enough' to the
   // previous scan, so no new request made.
   const int kSecondScanAps = kFirstScanAps - 1;
   MockDeviceDataProviderImpl<WifiData>::instance()->SetData(
       CreateReferenceWifiScanData(kSecondScanAps));
   main_message_loop_.RunAllPending();
   fetcher = url_fetcher_factory_.GetFetcherByID(kSecondScanAps);
   EXPECT_FALSE(fetcher);
@@ skipping 32 matching lines @@
   EXPECT_EQ(orig_fetcher, fetcher);  // No new request created.
 
   provider->GetPosition(&position);
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_TRUE(position.IsValidFix());
 }
 
 // TODO(joth): Add tests for corner cases around the 2 second startup delay
 //            (e.g. timer firing, or being pre-empted by data arriving)