Update the Nigori node when the passphrase changes.

chrome/browser/sync/profile_sync_service_password_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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/task.h"
 #include "base/time.h"
@@ skipping 104 matching lines @@
     notification_service_->Init();
   }
 
   virtual void TearDown() {
     service_.reset();
     notification_service_->TearDown();
     db_thread_.Stop();
     MessageLoop::current()->RunAllPending();
   }
 
-  void StartSyncService(Task* task) {
+  void StartSyncService(Task* root_task, Task* node_task) {
     if (!service_.get()) {
       service_.reset(new TestProfileSyncService(&factory_, &profile_,
                                                 false, false));
       service_->AddObserver(&observer_);
       PasswordDataTypeController* data_type_controller =
           new PasswordDataTypeController(&factory_,
                                          &profile_,
                                          service_.get());
 
       EXPECT_CALL(factory_, CreatePasswordSyncComponents(_, _, _)).
           WillOnce(MakePasswordSyncComponents(service_.get(),
                                               password_store_.get(),
                                               data_type_controller));
       EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
           WillOnce(MakeDataTypeManager(&backend_));
 
       EXPECT_CALL(profile_, GetPasswordStore(_)).
           WillOnce(Return(password_store_.get()));
 
       // State changes once for the backend init and once for startup done.
       EXPECT_CALL(observer_, OnStateChanged()).
-          WillOnce(Return()).
+          WillOnce(InvokeTask(root_task)).
           WillOnce(Return()).
           WillOnce(QuitUIMessageLoop());
 
       service_->RegisterDataTypeController(data_type_controller);
       service_->Initialize();
       MessageLoop::current()->Run();
 
-      EXPECT_CALL(observer_, OnStateChanged()).
-          WillOnce(InvokeTask(task)).
-          WillOnce(Return()).
-          WillOnce(QuitUIMessageLoop());
+      // Only set the passphrase if we actually created the password and nigori
+      // root nodes.
+      if (root_task) {
+        EXPECT_CALL(observer_, OnStateChanged()).
+            WillOnce(InvokeTask(node_task)).
+            WillOnce(Return()).
+            WillOnce(QuitUIMessageLoop());
 
-      service_->SetPassphrase("foo");
-      MessageLoop::current()->Run();
+        service_->SetPassphrase("foo");
+        MessageLoop::current()->Run();
+      }
     }
   }
 
   void CreatePasswordRoot() {
     UserShare* user_share = service_->backend()->GetUserShareHandle();
     DirectoryManager* dir_manager = user_share->dir_manager.get();
 
     ScopedDirLookup dir(dir_manager, user_share->authenticated_name);
     ASSERT_TRUE(dir.good());
 
     WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
-    MutableEntry node(&wtrans,
-                      CREATE,
-                      wtrans.root_id(),
-                      browser_sync::kPasswordTag);
-    node.Put(UNIQUE_SERVER_TAG, browser_sync::kPasswordTag);
-    node.Put(IS_DIR, true);
-    node.Put(SERVER_IS_DIR, false);
-    node.Put(IS_UNSYNCED, false);
-    node.Put(IS_UNAPPLIED_UPDATE, false);
-    node.Put(SERVER_VERSION, 20);
-    node.Put(BASE_VERSION, 20);
-    node.Put(IS_DEL, false);
-    node.Put(ID, ids_.MakeServer(browser_sync::kPasswordTag));
-    sync_pb::EntitySpecifics specifics;
-    specifics.MutableExtension(sync_pb::password);
-    node.Put(SPECIFICS, specifics);
+
+    MutableEntry password_node(&wtrans,
+                               CREATE,
+                               wtrans.root_id(),
+                               browser_sync::kPasswordTag);
+    password_node.Put(UNIQUE_SERVER_TAG, browser_sync::kPasswordTag);
+    password_node.Put(IS_DIR, true);
+    password_node.Put(SERVER_IS_DIR, false);
+    password_node.Put(IS_UNSYNCED, false);
+    password_node.Put(IS_UNAPPLIED_UPDATE, false);
+    password_node.Put(SERVER_VERSION, 20);
+    password_node.Put(BASE_VERSION, 20);
+    password_node.Put(IS_DEL, false);
+    password_node.Put(ID, ids_.MakeServer(browser_sync::kPasswordTag));
+    sync_pb::EntitySpecifics password_specifics;
+    password_specifics.MutableExtension(sync_pb::password);
+    password_node.Put(SPECIFICS, password_specifics);
+  }
+
+  void CreateNigoriRoot() {
+    UserShare* user_share = service_->backend()->GetUserShareHandle();
+    DirectoryManager* dir_manager = user_share->dir_manager.get();
+
+    ScopedDirLookup dir(dir_manager, user_share->authenticated_name);
+    ASSERT_TRUE(dir.good());
+
+    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+
+    MutableEntry nigori_node(&wtrans,
+                             CREATE,
+                             wtrans.root_id(),
+                             browser_sync::kNigoriTag);
+    nigori_node.Put(UNIQUE_SERVER_TAG, browser_sync::kNigoriTag);
+    nigori_node.Put(IS_DIR, false);
+    nigori_node.Put(SERVER_IS_DIR, false);
+    nigori_node.Put(IS_UNSYNCED, false);
+    nigori_node.Put(IS_UNAPPLIED_UPDATE, false);
+    nigori_node.Put(SERVER_VERSION, 20);
+    nigori_node.Put(BASE_VERSION, 20);
+    nigori_node.Put(IS_DEL, false);
+    nigori_node.Put(ID, ids_.MakeServer(browser_sync::kNigoriTag));
+    sync_pb::EntitySpecifics nigori_specifics;
+    nigori_specifics.MutableExtension(sync_pb::nigori);
+    nigori_node.Put(SPECIFICS, nigori_specifics);
   }
 
   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);
     std::string tag = PasswordModelAssociator::MakeTag(entry);
@@ skipping 34 matching lines @@
            lhs.username_value == rhs.username_value &&
            lhs.password_element == rhs.password_element &&
            lhs.password_value == rhs.password_value &&
            lhs.ssl_valid == rhs.ssl_valid &&
            lhs.preferred == rhs.preferred &&
            lhs.date_created == rhs.date_created &&
            lhs.blacklisted_by_user == rhs.blacklisted_by_user;
   }
 
   void SetIdleChangeProcessorExpectations() {
-    EXPECT_CALL(*(password_store_.get()), AddLoginImpl(_)).Times(0);
-    EXPECT_CALL(*(password_store_.get()), UpdateLoginImpl(_)).Times(0);
-    EXPECT_CALL(*(password_store_.get()), RemoveLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_, RemoveLoginImpl(_)).Times(0);
   }
 
   friend class CreatePasswordRootTask;
+  friend class CreateNigoriRootTask;
   friend class AddPasswordEntriesTask;
 
   MessageLoopForUI message_loop_;
   ChromeThread ui_thread_;
   ChromeThread db_thread_;
   scoped_refptr<ThreadNotificationService> notification_service_;
 
   scoped_ptr<TestProfileSyncService> service_;
   ProfileMock profile_;
   ProfileSyncFactoryMock factory_;
   ProfileSyncServiceObserverMock observer_;
   SyncBackendHostMock backend_;
   scoped_refptr<MockPasswordStore> password_store_;
 
   TestIdFactory ids_;
 };
 
 class CreatePasswordRootTask : public Task {
  public:
   explicit CreatePasswordRootTask(ProfileSyncServicePasswordTest* test)
       : test_(test) {
   }
 
   virtual void Run() {
+    test_->CreateNigoriRoot();
     test_->CreatePasswordRoot();
   }
 
  private:
   ProfileSyncServicePasswordTest* test_;
 };
 
+class CreateNigoriRootTask : public Task {
+ public:
+  explicit CreateNigoriRootTask(ProfileSyncServicePasswordTest* test)
+      : test_(test) {
+  }
+
+  virtual void Run() {
+    test_->CreateNigoriRoot();
+  }
+
+ private:
+  ProfileSyncServicePasswordTest* test_;
+};
+
 class AddPasswordEntriesTask : public Task {
  public:
   AddPasswordEntriesTask(ProfileSyncServicePasswordTest* test,
                          const std::vector<PasswordForm>& entries)
       : test_(test), entries_(entries) {
   }
 
   virtual void Run() {
-    test_->CreatePasswordRoot();
     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) {
   // Backend will be paused but not resumed.
   EXPECT_CALL(backend_, RequestPause()).
       WillRepeatedly(testing::DoAll(Notify(NotificationType::SYNC_PAUSED),
                                     testing::Return(true)));
-  // Don't create the root password node so startup fails.
-  StartSyncService(NULL);
+  // Create the nigori root node so that password model association is
+  // attempted, but not the password root node so that it fails.
+  CreateNigoriRootTask task(this);
+  StartSyncService(&task, NULL);
   EXPECT_TRUE(service_->unrecoverable_error_detected());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, EmptyNativeEmptySync) {
-  EXPECT_CALL(*(password_store_.get()), FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(Return(true));
-  EXPECT_CALL(*(password_store_.get()), FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreatePasswordRootTask task(this);
-  StartSyncService(&task);
+  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_.get()), FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
-  EXPECT_CALL(*(password_store_.get()), FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreatePasswordRootTask task(this);
-  StartSyncService(&task);
+  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 25 matching lines @@
     new_form->password_element = UTF8ToUTF16("cork");
     new_form->password_value = UTF8ToUTF16("password2");
     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_.get()), FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
-  EXPECT_CALL(*(password_store_.get()), FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreatePasswordRootTask task(this);
-  StartSyncService(&task);
+  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;
   std::vector<PasswordForm> sync_forms;
@@ skipping 28 matching lines @@
     new_form.password_element = UTF8ToUTF16("cork2");
     new_form.password_value = UTF8ToUTF16("password12");
     new_form.ssl_valid = false;
     new_form.preferred = true;
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     sync_forms.push_back(new_form);
     expected_forms.push_back(new_form);
   }
 
-  EXPECT_CALL(*(password_store_.get()), FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
-  EXPECT_CALL(*(password_store_.get()), FillBlacklistLogins(_))
-      .WillOnce(Return(true));
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
+  EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(1);
 
-  AddPasswordEntriesTask task(this, sync_forms);
-
-  EXPECT_CALL(*(password_store_.get()), AddLoginImpl(_)).Times(1);
-  StartSyncService(&task);
+  CreatePasswordRootTask root_task(this);
+  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]));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, HasNativeHasSyncMergeEntry) {
@@ skipping 45 matching lines @@
     new_form.username_value = UTF8ToUTF16("tom");
     new_form.password_element = UTF8ToUTF16("cork");
     new_form.password_value = UTF8ToUTF16("password12");
     new_form.ssl_valid = false;
     new_form.preferred = true;
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     expected_forms.push_back(new_form);
   }
 
-  EXPECT_CALL(*(password_store_.get()), FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
-  EXPECT_CALL(*(password_store_.get()), FillBlacklistLogins(_))
-      .WillOnce(Return(true));
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
+  EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(1);
 
-  AddPasswordEntriesTask task(this, sync_forms);
+  CreatePasswordRootTask root_task(this);
+  AddPasswordEntriesTask node_task(this, sync_forms);
 
-  EXPECT_CALL(*(password_store_.get()), UpdateLoginImpl(_)).Times(1);
-  StartSyncService(&task);
+  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]));
 }