[Sync] Refactored ProfileSyncService and remove its backend() function

chrome/browser/sync/profile_sync_service_autofill_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 <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 17 matching lines @@
 #include "chrome/browser/sync/glue/autofill_model_associator.h"
 #include "chrome/browser/sync/glue/autofill_profile_change_processor.h"
 #include "chrome/browser/sync/glue/autofill_profile_data_type_controller.h"
 #include "chrome/browser/sync/glue/autofill_profile_model_associator.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/sync/syncable/autofill_migration.h"
+#include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/test/profile_mock.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::Time;
 using base::WaitableEvent;
 using browser_sync::AutofillChangeProcessor;
 using browser_sync::AutofillDataTypeController;
 using browser_sync::AutofillModelAssociator;
 using browser_sync::AutofillProfileChangeProcessor;
 using browser_sync::AutofillProfileDataTypeController;
 using browser_sync::AutofillProfileModelAssociator;
 using browser_sync::DataTypeController;
 using browser_sync::GROUP_DB;
 using browser_sync::kAutofillTag;
 using browser_sync::SyncBackendHostForProfileSyncTest;
 using browser_sync::SyncerUtil;
 using browser_sync::UnrecoverableErrorHandler;
 using syncable::CREATE_NEW_UPDATE_ITEM;
 using syncable::AUTOFILL;
+using syncable::BASE_VERSION;
+using syncable::CREATE;
 using syncable::DirectoryChangeEvent;
 using syncable::GET_BY_SERVER_TAG;
 using syncable::INVALID;
+using syncable::MutableEntry;
+using syncable::OriginalEntries;
 using syncable::SERVER_PARENT_ID;
 using syncable::SERVER_SPECIFICS;
-using syncable::OriginalEntries;
+using syncable::SPECIFICS;
+using syncable::UNITTEST;
 using syncable::WriterTag;
 using syncable::WriteTransaction;
 using testing::_;
 using testing::DoAll;
 using testing::DoDefault;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Invoke;
 using testing::Mock;
 using testing::Return;
@@ skipping 224 matching lines @@
     EXPECT_CALL(profile_, GetTokenService()).
         WillRepeatedly(Return(&token_service_));
 
     service_->set_num_expected_resumes(will_fail_association ? 0 : 1);
     service_->RegisterDataTypeController(data_type_controller);
     service_->Initialize();
     MessageLoop::current()->Run();
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
-    sync_api::WriteTransaction trans(
-        service_->backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShareHandle());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillTag))
       return false;
 
     sync_api::WriteNode node(&trans);
     std::string tag = AutofillModelAssociator::KeyToTag(entry.key().name(),
                                                         entry.key().value());
     if (!node.InitUniqueByCreation(syncable::AUTOFILL, autofill_root, tag))
       return false;
 
     AutofillChangeProcessor::WriteAutofillEntry(entry, &node);
     return true;
   }
 
   bool AddAutofillSyncNode(const AutoFillProfile& profile) {
-    sync_api::WriteTransaction trans(
-        service_->backend()->GetUserShareHandle());
+    sync_api::WriteTransaction trans(service_->GetUserShareHandle());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
       return false;
     sync_api::WriteNode node(&trans);
     std::string tag = profile.guid();
     if (!node.InitUniqueByCreation(syncable::AUTOFILL_PROFILE,
         autofill_root, tag))
       return false;
     AutofillProfileChangeProcessor::WriteAutofillProfile(profile, &node);
     return true;
   }
 
   bool GetAutofillEntriesFromSyncDB(std::vector<AutofillEntry>* entries,
                                     std::vector<AutoFillProfile>* profiles) {
-    sync_api::ReadTransaction trans(service_->backend()->GetUserShareHandle());
+    sync_api::ReadTransaction trans(service_->GetUserShareHandle());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillTag))
       return false;
 
     int64 child_id = autofill_root.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       sync_api::ReadNode child_node(&trans);
       if (!child_node.InitByIdLookup(child_id))
         return false;
 
@@ skipping 16 matching lines @@
             autofill.profile());
         profiles->push_back(p);
       }
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   bool GetAutofillProfilesFromSyncDBUnderProfileNode(
       std::vector<AutoFillProfile>* profiles) {
-    sync_api::ReadTransaction trans(service_->backend()->GetUserShareHandle());
+    sync_api::ReadTransaction trans(service_->GetUserShareHandle());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
       return false;
 
     int64 child_id = autofill_root.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       sync_api::ReadNode child_node(&trans);
       if (!child_node.InitByIdLookup(child_id))
         return false;
 
@@ skipping 69 matching lines @@
  private:
   ProfileSyncServiceAutofillTest* test_;
   const std::vector<T>& entries_;
   bool success_;
 };
 
 // Overload write transaction to use custom NotifyTransactionComplete
 static const bool kLoggingInfo = true;
 class WriteTransactionTest: public WriteTransaction {
  public:
-  WriteTransactionTest(const ScopedDirLookup& directory,
+  WriteTransactionTest(const syncable::ScopedDirLookup& directory,
                        WriterTag writer, const char* source_file,
                        int line,
                        scoped_ptr<WaitableEvent> *wait_for_syncapi)
       : WriteTransaction(directory, writer, source_file, line),
         wait_for_syncapi_(wait_for_syncapi) { }
 
   virtual void NotifyTransactionComplete() {
     // This is where we differ. Force a thread change here, giving another
     // thread a chance to create a WriteTransaction
     (*wait_for_syncapi_)->Wait();
@@ skipping 15 matching lines @@
       : entry_(ProfileSyncServiceAutofillTest::MakeAutofillEntry("0", "0", 0)),
         service_(service),
         wait_for_start_(wait_for_start),
         wait_for_syncapi_(wait_for_syncapi),
         is_finished_(false, false) { }
 
   void Update() {
     // This gets called in a modelsafeworker thread.
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
-    UserShare* user_share = service_->backend()->GetUserShareHandle();
-    DirectoryManager* dir_manager = user_share->dir_manager.get();
-    ScopedDirLookup dir(dir_manager, user_share->name);
+    browser_sync::SyncBackendHost::UserShareHandle user_share =

[tim (not reviewing), 2011/01/21 18:17:00]

something about getting a pointer from the service that is typedef'd from SBH
seems weird. Should we just use sync_api::UserShare* and be done with it?  Or
maybe just move the typedef into browser_sync vs inside SBH.  That would be a
little less circuitous I think.

+        service_->GetUserShareHandle();
+    syncable::DirectoryManager* dir_manager = user_share->dir_manager.get();
+    syncable::ScopedDirLookup dir(dir_manager, user_share->name);
     ASSERT_TRUE(dir.good());
 
     // Create autofill protobuf
     std::string tag = AutofillModelAssociator::KeyToTag(entry_.key().name(),
                                                         entry_.key().value());
     sync_pb::AutofillSpecifics new_autofill;
     new_autofill.set_name(UTF16ToUTF8(entry_.key().name()));
     new_autofill.set_value(UTF16ToUTF8(entry_.key().value()));
     const std::vector<base::Time>& ts(entry_.timestamps());
     for (std::vector<base::Time>::const_iterator timestamp = ts.begin();
@@ skipping 30 matching lines @@
     }
     VLOG(1) << "FakeServerUpdater finishing.";
     is_finished_.Signal();
   }
 
   void CreateNewEntry(const AutofillEntry& entry) {
     entry_ = entry;
     scoped_ptr<Callback0::Type> c(NewCallback((FakeServerUpdater *)this,
                                               &FakeServerUpdater::Update));
     std::vector<browser_sync::ModelSafeWorker*> workers;
-    service_->backend()->GetWorkers(&workers);
+    service_->GetTestBackend()->GetWorkers(&workers);

[tim (not reviewing), 2011/01/21 18:17:00]

why GetTestBackend()? I would have just expected GetBackendForTest() since you
added that. GetWorkers exists there. Do we srsly need both?

[akalin, 2011/01/21 21:21:09]

The alternative was to override GetBackendForTest() and make it public.  I guess
that's less smelly, though.

 
     ASSERT_FALSE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     if (!BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
          NewRunnableMethod(this, &FakeServerUpdater::Update))) {
       NOTREACHED() << "Failed to post task to the db thread.";
       return;
     }
   }
 
   void CreateNewEntryAndWait(const AutofillEntry& entry) {
     entry_ = entry;
     scoped_ptr<Callback0::Type> c(NewCallback((FakeServerUpdater *)this,
                                               &FakeServerUpdater::Update));
     std::vector<browser_sync::ModelSafeWorker*> workers;
-    service_->backend()->GetWorkers(&workers);
+    service_->GetTestBackend()->GetWorkers(&workers);
 
     ASSERT_FALSE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     is_finished_.Reset();
     if (!BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
          NewRunnableMethod(this, &FakeServerUpdater::Update))) {
       NOTREACHED() << "Failed to post task to the db thread.";
       return;
     }
     is_finished_.Wait();
   }
@@ skipping 475 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutoFillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     VLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
             << ", " << sync_entries[i].key().value();
   }
 }