Have AutofillManagerDelegate supply the AutofillWebDataService to core code.

components/autofill/core/browser/personal_data_manager_unittest.cc

 // Copyright 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 <string>
 
 #include "base/basictypes.h"
 #include "base/guid.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/personal_data_manager_observer.h"
+#include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/form_data.h"
+#include "components/webdata/common/web_data_service_base.h"
+#include "components/webdata/common/web_database_service.h"
 #include "components/webdata/encryptor/encryptor.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace autofill {
 namespace {
 
@@ skipping 24 matching lines @@
 class PersonalDataManagerTest : public testing::Test {
  protected:
   PersonalDataManagerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB) {
   }
 
   virtual void SetUp() {
     db_thread_.Start();
 
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    base::FilePath path = temp_dir_.path().AppendASCII("TestWebDB");
+    web_database_ = new WebDatabaseService(
+        path,
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB));
+    web_database_->AddTable(
+        scoped_ptr<WebDatabaseTable>(new AutofillTable("en-US")));
+    web_database_->LoadDatabase();
+    autofill_database_service_ = new AutofillWebDataService(
+        web_database_,
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
+        WebDataServiceBase::ProfileErrorCallback());
+    autofill_database_service_->Init();
+
     profile_.reset(new TestingProfile);
     profile_->CreateWebDataService();
 
     test::DisableSystemServices(profile_.get());
     ResetPersonalDataManager();
   }
 
   virtual void TearDown() {
     // Destruction order is imposed explicitly here.
     personal_data_.reset(NULL);
     profile_.reset(NULL);
 
+    autofill_database_service_->ShutdownOnUIThread();
+    web_database_->ShutdownDatabase();
+    autofill_database_service_ = NULL;
+    web_database_ = NULL;
+
     // Schedule another task on the DB thread to notify us that it's safe to
     // stop the thread.
     base::WaitableEvent done(false, false);
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
     done.Wait();
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
     db_thread_.Stop();
   }
 
   void ResetPersonalDataManager() {
     personal_data_.reset(new PersonalDataManager("en-US"));
-    personal_data_->Init(profile_.get(),
-                         profile_->GetPrefs(),
-                         profile_->IsOffTheRecord());
+    personal_data_->Init(
+        scoped_refptr<AutofillWebDataService>(autofill_database_service_),
+        profile_->GetPrefs(),
+        profile_->IsOffTheRecord());
     personal_data_->AddObserver(&personal_data_observer_);
 
     // Verify that the web database has been updated and the notification sent.
     EXPECT_CALL(personal_data_observer_,
                 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
     base::MessageLoop::current()->Run();
   }
 
   void MakeProfileIncognito() {
     // Switch to an incognito profile.
     profile_->ForceIncognito(true);
     DCHECK(profile_->IsOffTheRecord());
   }
 
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   scoped_ptr<TestingProfile> profile_;
+  scoped_refptr<AutofillWebDataService> autofill_database_service_;
+  scoped_refptr<WebDatabaseService> web_database_;
+  base::ScopedTempDir temp_dir_;
   scoped_ptr<PersonalDataManager> personal_data_;
   PersonalDataLoadedObserverMock personal_data_observer_;
 };
 
 TEST_F(PersonalDataManagerTest, AddProfile) {
   // Add profile0 to the database.
   AutofillProfile profile0(autofill::test::GetFullProfile());
   profile0.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com"));
   personal_data_->AddProfile(profile0);
 
@@ skipping 405 matching lines @@
   AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile2,
       "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   // Adjust all labels.
   profile_pointers.push_back(&profile2);
   AutofillProfile::AdjustInferredLabels(&profile_pointers);
 
-  scoped_refptr<AutofillWebDataService> wds =
-      AutofillWebDataService::FromBrowserContext(profile_.get());
-  ASSERT_TRUE(wds.get());
-  wds->AddAutofillProfile(profile2);
+  autofill_database_service_->AddAutofillProfile(profile2);
 
   personal_data_->Refresh();
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   base::MessageLoop::current()->Run();
 
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(3U, results2.size());
   EXPECT_EQ(profile0, *results2[0]);
   EXPECT_EQ(profile1, *results2[1]);
   EXPECT_EQ(profile2, *results2[2]);
 
-  wds->RemoveAutofillProfile(profile1.guid());
-  wds->RemoveAutofillProfile(profile2.guid());
+  autofill_database_service_->RemoveAutofillProfile(profile1.guid());
+  autofill_database_service_->RemoveAutofillProfile(profile2.guid());
 
   // Before telling the PDM to refresh, simulate an edit to one of the deleted
   // profiles via a SetProfile update (this would happen if the Autofill window
   // was open with a previous snapshot of the profiles, and something
   // [e.g. sync] removed a profile from the browser.  In this edge case, we will
   // end up in a consistent state by dropping the write).
   profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Mar"));
   profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jo"));
   personal_data_->UpdateProfile(profile0);
   personal_data_->AddProfile(profile1);
@@ skipping 1915 matching lines @@
   AutofillProfile space_invader(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&space_invader, "Marty", "", "Martian",
       "mm@example.com", "", "1 Flying Object", "", "Valles Marineris", "",
       "", "XX", "");
   personal_data_->AddProfile(moose);
   ResetPersonalDataManager();
   EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress());
 }
 
 }  // namespace autofill