Turn password sync on by default.

chrome/browser/sync/profile_sync_service_password_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+1;2c// 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 159 matching lines @@
           WillRepeatedly(Return(password_store_.get()));
 
       EXPECT_CALL(observer_,
           Observe(
               NotificationType(NotificationType::SYNC_CONFIGURE_DONE),_,_));
 
       service_->RegisterDataTypeController(data_type_controller);
       service_->Initialize();
       MessageLoop::current()->Run();
 
-      // Only set the passphrase if we actually created the password and nigori
-      // root nodes.
-      if (root_task) {
-        EXPECT_CALL(observer_,
-            Observe(
-                NotificationType(NotificationType::SYNC_PASSPHRASE_ACCEPTED),
-                    _,_)).
-            WillOnce(InvokeTask(node_task));
-        EXPECT_CALL(observer_,
-            Observe(
-                NotificationType(NotificationType::SYNC_CONFIGURE_DONE),
-                    _,_)).
-            WillOnce(QuitUIMessageLoop());
-        service_->SetPassphrase("foo", false, true);
-        MessageLoop::current()->Run();
-      }
+      EXPECT_CALL(
+          observer_,
+          Observe(
+              NotificationType(NotificationType::SYNC_PASSPHRASE_ACCEPTED),
+              _,_)).
+          WillOnce(InvokeTask(node_task));
+      EXPECT_CALL(
+          observer_,
+          Observe(
+              NotificationType(NotificationType::SYNC_CONFIGURE_DONE),
+              _,_)).
+          WillOnce(QuitUIMessageLoop());
+      service_->SetPassphrase("foo", false, true);
+      MessageLoop::current()->Run();
     }
   }
 
   void AddPasswordSyncNode(const PasswordForm& entry) {
     sync_api::WriteTransaction trans(
         service_->backend()->GetUserShareHandle());
     sync_api::ReadNode password_root(&trans);
     ASSERT_TRUE(password_root.InitByTagLookup(browser_sync::kPasswordTag));
 
     sync_api::WriteNode node(&trans);
@@ skipping 49 matching lines @@
 
   friend class AddPasswordEntriesTask;
 
   BrowserThread db_thread_;
   scoped_refptr<ThreadNotificationService> notification_service_;
   NotificationObserverMock observer_;
   ProfileMock profile_;
   scoped_refptr<MockPasswordStore> password_store_;
   NotificationRegistrar registrar_;
 
-  TestIdFactory ids_;
-};
-
-class CreatePasswordRootTask : public Task {
- public:
-  explicit CreatePasswordRootTask(AbstractProfileSyncServiceTest* test)
-      : test_(test) {
-  }
-
-  virtual void Run() {
-    test_->CreateRoot(syncable::NIGORI);
-    test_->CreateRoot(syncable::PASSWORDS);
-  }
-
- private:
-  AbstractProfileSyncServiceTest* test_;
 };
 
 class AddPasswordEntriesTask : public Task {
  public:
   AddPasswordEntriesTask(ProfileSyncServicePasswordTest* test,
                          const std::vector<PasswordForm>& entries)
       : test_(test), entries_(entries) {
   }
 
   virtual void Run() {
     for (size_t i = 0; i < entries_.size(); ++i) {
       test_->AddPasswordSyncNode(entries_[i]);
     }
   }
 
  private:
   ProfileSyncServicePasswordTest* test_;
   const std::vector<PasswordForm>& entries_;
 };
 
 TEST_F(ProfileSyncServicePasswordTest, FailModelAssociation) {
-  // Create the nigori root node so that password model association is
-  // attempted, but not the password root node so that it fails.
-  CreateRootTask task(this, syncable::NIGORI);
-  StartSyncService(&task, NULL, 1, 2);
+  StartSyncService(NULL, NULL, 1, 2);
   EXPECT_TRUE(service_->unrecoverable_error_detected());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, EmptyNativeEmptySync) {
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(Return(true));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreatePasswordRootTask task(this);
+  CreateRootTask task(this, syncable::PASSWORDS);
   StartSyncService(&task, NULL);
   std::vector<PasswordForm> sync_entries;
   GetPasswordEntriesFromSyncDB(&sync_entries);
   EXPECT_EQ(0U, sync_entries.size());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeEntriesEmptySync) {
   std::vector<PasswordForm*> forms;
   std::vector<PasswordForm> expected_forms;
   PasswordForm* new_form = new PasswordForm;
   new_form->scheme = PasswordForm::SCHEME_HTML;
   new_form->signon_realm = "pie";
   new_form->origin = GURL("http://pie.com");
   new_form->action = GURL("http://pie.com/submit");
   new_form->username_element = UTF8ToUTF16("name");
   new_form->username_value = UTF8ToUTF16("tom");
   new_form->password_element = UTF8ToUTF16("cork");
   new_form->password_value = UTF8ToUTF16("password1");
   new_form->ssl_valid = true;
   new_form->preferred = false;
   new_form->date_created = base::Time::FromInternalValue(1234);
   new_form->blacklisted_by_user = false;
   forms.push_back(new_form);
   expected_forms.push_back(*new_form);
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreatePasswordRootTask task(this);
+  CreateRootTask task(this, syncable::PASSWORDS);
   StartSyncService(&task, NULL);
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(1U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[0]));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeEntriesEmptySyncSameUsername) {
   std::vector<PasswordForm*> forms;
   std::vector<PasswordForm> expected_forms;
@@ skipping 31 matching lines @@
     new_form->blacklisted_by_user = false;
     forms.push_back(new_form);
     expected_forms.push_back(*new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreatePasswordRootTask task(this);
+  CreateRootTask task(this, syncable::PASSWORDS);
   StartSyncService(&task, NULL);
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(2U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[1]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], sync_forms[0]));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeHasSyncNoMerge) {
   std::vector<PasswordForm*> native_forms;
@@ skipping 34 matching lines @@
     new_form.blacklisted_by_user = false;
     sync_forms.push_back(new_form);
     expected_forms.push_back(new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(1);
 
-  CreatePasswordRootTask root_task(this);
+  CreateRootTask root_task(this, syncable::PASSWORDS);
   AddPasswordEntriesTask node_task(this, sync_forms);
   StartSyncService(&root_task, &node_task);
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1]));
 }
@@ skipping 52 matching lines @@
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     expected_forms.push_back(new_form);
   }
 
   EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
   EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(1);
 
-  CreatePasswordRootTask root_task(this);
+  CreateRootTask root_task(this, syncable::PASSWORDS);
   AddPasswordEntriesTask node_task(this, sync_forms);
 
   StartSyncService(&root_task, &node_task);
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(1U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
 }