Correctly integrate StoragePartition into TestingProfile.

chrome/browser/spellchecker/spellcheck_custom_dictionary_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 <vector>
 
 #include "base/file_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "net/url_request/test_url_fetcher_factory.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::HistogramBase;
 using base::HistogramSamples;
 using base::StatisticsRecorder;
-using content::BrowserThread;
 using chrome::spellcheck_common::WordList;
 using chrome::spellcheck_common::WordSet;
 
 namespace {
 
 // Get all sync data for the custom dictionary without limiting to maximum
 // number of syncable words.
 syncer::SyncDataList GetAllSyncDataNoLimit(
     const SpellcheckCustomDictionary* dictionary) {
   syncer::SyncDataList data;
@@ skipping 10 matching lines @@
 
 }  // namespace
 
 static BrowserContextKeyedService* BuildSpellcheckService(
     content::BrowserContext* profile) {
   return new SpellcheckService(static_cast<Profile*>(profile));
 }
 
 class SpellcheckCustomDictionaryTest : public testing::Test {
  protected:
-  SpellcheckCustomDictionaryTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE, &message_loop_),
-        profile_(new TestingProfile) {
-  }
-
   virtual void SetUp() OVERRIDE {
     // Use SetTestingFactoryAndUse to force creation and initialization.
     SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-        profile_.get(), &BuildSpellcheckService);
+        &profile_, &BuildSpellcheckService);
 
     StatisticsRecorder::Initialize();
   }
 
-  virtual void TearDown() OVERRIDE {
-    base::MessageLoop::current()->RunUntilIdle();
-  }
-
   // A wrapper around SpellcheckCustomDictionary::LoadDictionaryFile private
   // function to avoid a large number of FRIEND_TEST declarations in
   // SpellcheckCustomDictionary.
   chrome::spellcheck_common::WordList LoadDictionaryFile(
       const base::FilePath& path) {
     return SpellcheckCustomDictionary::LoadDictionaryFile(path);
   }
 
   // A wrapper around SpellcheckCustomDictionary::UpdateDictionaryFile private
   // function to avoid a large number of FRIEND_TEST declarations in
@@ skipping 14 matching lines @@
   }
 
   // A wrapper around SpellcheckCustomDictionary::Apply private method to avoid
   // a large number of FRIEND_TEST declarations in SpellcheckCustomDictionary.
   void Apply(
       SpellcheckCustomDictionary& dictionary,
       const SpellcheckCustomDictionary::Change& change) {
     return dictionary.Apply(change);
   }
 
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
 
-  scoped_ptr<TestingProfile> profile_;
+  TestingProfile profile_;
+  net::TestURLFetcherFactory fetcher_factory_;
 };
 
 // A wrapper around SpellcheckCustomDictionary that does not own the wrapped
 // object. An instance of this class can be inside of a scoped pointer safely
 // while the dictionary is managed by another scoped pointer.
 class SyncChangeProcessorDelegate : public syncer::SyncChangeProcessor {
  public:
   explicit SyncChangeProcessorDelegate(SpellcheckCustomDictionary* dictionary)
       : dictionary_(dictionary) {}
   virtual ~SyncChangeProcessorDelegate() {}
@@ skipping 50 matching lines @@
       const SpellcheckCustomDictionary::Change& change) OVERRIDE { changes_++; }
 
  private:
   int loads_;
   int changes_;
   DISALLOW_COPY_AND_ASSIGN(DictionaryObserverCounter);
 };
 
 TEST_F(SpellcheckCustomDictionaryTest, SaveAndLoad) {
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
   WordList loaded_custom_words = LoadDictionaryFile(path);
 
   // The custom word list should be empty now.
   WordList expected;
   EXPECT_EQ(expected, loaded_custom_words);
 
   SpellcheckCustomDictionary::Change change;
   change.AddWord("bar");
   change.AddWord("foo");
 
   UpdateDictionaryFile(change, path);
   expected.push_back("bar");
   expected.push_back("foo");
 
   // The custom word list should include written words.
   loaded_custom_words = LoadDictionaryFile(path);
   EXPECT_EQ(expected, loaded_custom_words);
 
   change = SpellcheckCustomDictionary::Change();
   change.RemoveWord("bar");
   change.RemoveWord("foo");
   UpdateDictionaryFile(change, path);
   loaded_custom_words = LoadDictionaryFile(path);
   expected.clear();
   EXPECT_EQ(expected, loaded_custom_words);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, MultiProfile) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 13 matching lines @@
   WordSet actual1 = custom_dictionary->GetWords();
   EXPECT_EQ(actual1, expected1);
 
   WordSet actual2 = custom_dictionary2->GetWords();
   EXPECT_EQ(actual2, expected2);
 }
 
 // Legacy empty dictionary should be converted to new format empty dictionary.
 TEST_F(SpellcheckCustomDictionaryTest, LegacyEmptyDictionaryShouldBeConverted) {
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
 
   std::string content;
   file_util::WriteFile(path, content.c_str(), content.length());
   WordList loaded_custom_words = LoadDictionaryFile(path);
   EXPECT_TRUE(loaded_custom_words.empty());
 }
 
 // Legacy dictionary with two words should be converted to new format dictionary
 // with two words.
 TEST_F(SpellcheckCustomDictionaryTest,
        LegacyDictionaryWithTwoWordsShouldBeConverted) {
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
 
   std::string content = "foo\nbar\nfoo\n";
   file_util::WriteFile(path, content.c_str(), content.length());
   WordList loaded_custom_words = LoadDictionaryFile(path);
   WordList expected;
   expected.push_back("bar");
   expected.push_back("foo");
   EXPECT_EQ(expected, loaded_custom_words);
 }
 
 // Illegal words should be removed. Leading and trailing whitespace should be
 // trimmed.
 TEST_F(SpellcheckCustomDictionaryTest,
        IllegalWordsShouldBeRemovedFromDictionary) {
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
 
   std::string content = "foo\n foo bar \n\n \nbar\n"
       "01234567890123456789012345678901234567890123456789"
       "01234567890123456789012345678901234567890123456789";
   file_util::WriteFile(path, content.c_str(), content.length());
   WordList loaded_custom_words = LoadDictionaryFile(path);
   WordList expected;
   expected.push_back("bar");
   expected.push_back("foo");
   expected.push_back("foo bar");
   EXPECT_EQ(expected, loaded_custom_words);
 }
 
 // Write to dictionary should backup previous version and write the word to the
 // end of the dictionary. If the dictionary file is corrupted on disk, the
 // previous version should be reloaded.
 TEST_F(SpellcheckCustomDictionaryTest, CorruptedWriteShouldBeRecovered) {
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
 
   std::string content = "foo\nbar";
   file_util::WriteFile(path, content.c_str(), content.length());
   WordList loaded_custom_words = LoadDictionaryFile(path);
   WordList expected;
   expected.push_back("bar");
   expected.push_back("foo");
   EXPECT_EQ(expected, loaded_custom_words);
 
   SpellcheckCustomDictionary::Change change;
   change.AddWord("baz");
   UpdateDictionaryFile(change, path);
   content.clear();
   file_util::ReadFileToString(path, &content);
   content.append("corruption");
   file_util::WriteFile(path, content.c_str(), content.length());
   loaded_custom_words = LoadDictionaryFile(path);
   EXPECT_EQ(expected, loaded_custom_words);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest,
        GetAllSyncDataAccuratelyReflectsDictionaryState) {
   SpellcheckCustomDictionary* dictionary =
       SpellcheckServiceFactory::GetForProfile(
-          profile_.get())->GetCustomDictionary();
+          &profile_)->GetCustomDictionary();
 
   syncer::SyncDataList data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_TRUE(data.empty());
 
   EXPECT_TRUE(dictionary->AddWord("bar"));
   EXPECT_TRUE(dictionary->AddWord("foo"));
 
   data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_EQ(2UL, data.size());
   std::vector<std::string> words;
   words.push_back("bar");
   words.push_back("foo");
   for (size_t i = 0; i < data.size(); i++) {
     EXPECT_TRUE(data[i].GetSpecifics().has_dictionary());
     EXPECT_EQ(syncer::DICTIONARY, data[i].GetDataType());
     EXPECT_EQ(words[i], data[i].GetTag());
     EXPECT_EQ(words[i], data[i].GetSpecifics().dictionary().word());
   }
 
   EXPECT_TRUE(dictionary->RemoveWord("bar"));
   EXPECT_TRUE(dictionary->RemoveWord("foo"));
 
   data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_TRUE(data.empty());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, GetAllSyncDataHasLimit) {
   SpellcheckCustomDictionary* dictionary =
       SpellcheckServiceFactory::GetForProfile(
-          profile_.get())->GetCustomDictionary();
+          &profile_)->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
        i++) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*dictionary, change);
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
             dictionary->GetWords().size());
@@ skipping 14 matching lines @@
 
   dictionary->AddWord("snafoo");
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 2,
             dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, ProcessSyncChanges) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* dictionary =
       spellcheck_service->GetCustomDictionary();
 
   dictionary->AddWord("foo");
   dictionary->AddWord("bar");
 
   syncer::SyncChangeList changes;
   {
     // Add existing word.
     std::string word = "foo";
@@ skipping 50 matching lines @@
 
   const WordSet& words = dictionary->GetWords();
   EXPECT_EQ(2UL, words.size());
   EXPECT_EQ(0UL, words.count("bar"));
   EXPECT_EQ(1UL, words.count("foo"));
   EXPECT_EQ(1UL, words.count("baz"));
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, MergeDataAndStartSyncing) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 25 matching lines @@
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   WordSet words = custom_dictionary->GetWords();
   WordSet words2 = custom_dictionary2->GetWords();
   EXPECT_EQ(words.size(), words2.size());
   EXPECT_EQ(words, words2);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigBeforeSyncing) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 22 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigAndServerFull) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 31 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, ServerTooBig) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 30 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToStartSyncing) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 25 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToContiueSyncing) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 30 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStart) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(2UL, custom_dictionary->GetWords().size());
   EXPECT_EQ(2UL, custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(2UL, custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(2UL, custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStartTooBigToSync) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 26 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadDuplicatesAfterSync) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 26 matching lines @@
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryLoadNotification) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
 
   DictionaryObserverCounter observer;
   custom_dictionary->AddObserver(&observer);
 
   WordList custom_words;
   custom_words.push_back("foo");
   custom_words.push_back("bar");
   OnLoaded(*custom_dictionary, custom_words);
 
   EXPECT_GE(observer.loads(), 1);
   EXPECT_LE(observer.loads(), 2);
   EXPECT_EQ(0, observer.changes());
 
   custom_dictionary->RemoveObserver(&observer);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryAddWordNotification) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
 
   OnLoaded(*custom_dictionary, WordList());
 
   DictionaryObserverCounter observer;
   custom_dictionary->AddObserver(&observer);
 
   EXPECT_TRUE(custom_dictionary->AddWord("foo"));
   EXPECT_TRUE(custom_dictionary->AddWord("bar"));
   EXPECT_FALSE(custom_dictionary->AddWord("bar"));
 
   EXPECT_EQ(2, observer.changes());
 
   custom_dictionary->RemoveObserver(&observer);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryRemoveWordNotification) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
 
   OnLoaded(*custom_dictionary, WordList());
 
   EXPECT_TRUE(custom_dictionary->AddWord("foo"));
   EXPECT_TRUE(custom_dictionary->AddWord("bar"));
 
   DictionaryObserverCounter observer;
   custom_dictionary->AddObserver(&observer);
 
   EXPECT_TRUE(custom_dictionary->RemoveWord("foo"));
   EXPECT_TRUE(custom_dictionary->RemoveWord("bar"));
   EXPECT_FALSE(custom_dictionary->RemoveWord("baz"));
 
   EXPECT_EQ(2, observer.changes());
 
   custom_dictionary->RemoveObserver(&observer);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionarySyncNotification) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
@@ skipping 40 matching lines @@
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &server_profile, &BuildSpellcheckService));
 
   // Here, |server_custom_dictionary| plays the role of the sync server.
   SpellcheckCustomDictionary* server_custom_dictionary =
       server_spellcheck_service->GetCustomDictionary();
 
   // Upload the maximum number of words to the sync server.
   {
     SpellcheckService* spellcheck_service =
-        SpellcheckServiceFactory::GetForProfile(profile_.get());
+        SpellcheckServiceFactory::GetForProfile(&profile_);
     SpellcheckCustomDictionary* custom_dictionary =
         spellcheck_service->GetCustomDictionary();
 
     SpellcheckCustomDictionary::Change change;
     for (size_t i = 0;
          i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
          ++i) {
       change.AddWord("foo" + base::Uint64ToString(i));
     }
     Apply(*custom_dictionary, change);
@@ skipping 65 matching lines @@
   // Record a baseline.
   SpellCheckHostMetrics::RecordCustomWordCountStats(123);
 
   HistogramBase* histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> baseline = histogram->SnapshotSamples();
 
   // Load the dictionary which should be empty.
   base::FilePath path =
-      profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
   WordList loaded_custom_words = LoadDictionaryFile(path);
   EXPECT_EQ(0u, loaded_custom_words.size());
 
   // We expect there to be an entry with 0.
   histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
 
   samples->Subtract(*baseline);
@@ skipping 12 matching lines @@
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
 
   samples2->Subtract(*baseline);
   EXPECT_EQ(2,samples2->sum());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, HasWord) {
   SpellcheckService* spellcheck_service =
-      SpellcheckServiceFactory::GetForProfile(profile_.get());
+      SpellcheckServiceFactory::GetForProfile(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   OnLoaded(*custom_dictionary, WordList());
   EXPECT_FALSE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
   custom_dictionary->AddWord("foo");
   EXPECT_TRUE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
 }