Update incomplete credentials in Login Database

chrome/browser/password_manager/password_form_manager_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_form_manager.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/password_manager/password_manager_client.h"
 #include "chrome/browser/password_manager/password_manager_driver.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/common/password_form.h"
+#include "components/password_manager/core/browser/mock_password_store.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/test_password_store.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using autofill::PasswordForm;
 using base::ASCIIToUTF16;
 using ::testing::_;
 using ::testing::Eq;
 using ::testing::Mock;
+using ::testing::Return;
 
 namespace autofill {
 class AutofillManager;
 }
 
 namespace {
 
 class MockPasswordManagerDriver : public PasswordManagerDriver {
  public:
   MockPasswordManagerDriver() {}
@@ skipping 78 matching lines @@
     saved_match_.preferred = true;
     saved_match_.username_value = ASCIIToUTF16("test@gmail.com");
     saved_match_.password_value = ASCIIToUTF16("test1");
     saved_match_.other_possible_usernames.push_back(
         ASCIIToUTF16("test2@gmail.com"));
     profile_ = new TestingProfile();
   }
 
   virtual void TearDown() {
     delete profile_;
+    if (mock_store_)
+      mock_store_->Shutdown();
+  }
+
+  void InitializeMockStore() {
+    if (!mock_store_) {
+      mock_store_ = new MockPasswordStore();
+      ASSERT_TRUE(mock_store_);
+    }
+  }
+
+  MockPasswordStore* mock_store() const {
+    return mock_store_.get();
   }
 
   PasswordForm* GetPendingCredentials(PasswordFormManager* p) {
     return &p->pending_credentials_;
   }
 
   void SimulateMatchingPhase(PasswordFormManager* p, bool find_match) {
     // Roll up the state to mock out the matching phase.
     p->state_ = PasswordFormManager::POST_MATCHING_PHASE;
     if (!find_match)
@@ skipping 35 matching lines @@
     // Owned by the caller of this method.
     PasswordForm* match = new PasswordForm(saved_match_);
     match->blacklisted_by_user = blacklisted;
     return match;
   }
 
  private:
   PasswordForm observed_form_;
   PasswordForm saved_match_;
   Profile* profile_;
+  scoped_refptr<MockPasswordStore> mock_store_;
 };
 
 TEST_F(PasswordFormManagerTest, TestNewLogin) {
   scoped_ptr<TestPasswordManagerClient> client(
       new TestPasswordManagerClient(profile(), NULL));
   scoped_ptr<MockPasswordManagerDriver> driver;
   PasswordFormManager* manager = new PasswordFormManager(
       NULL, client.get(), driver.get(), *observed_form(), false);
 
   SimulateMatchingPhase(manager, false);
@@ skipping 462 matching lines @@
 
   SanitizePossibleUsernames(manager.get(), &credentials);
 
   // SSN, duplicate in |other_possible_usernames| and duplicate of
   // |username_value| all removed.
   expected.clear();
   expected.push_back(ASCIIToUTF16("duplicate"));
   expected.push_back(ASCIIToUTF16("random"));
   EXPECT_THAT(credentials.other_possible_usernames, Eq(expected));
 }
+
+TEST_F(PasswordFormManagerTest, TestUpdateIncompleteCredentials) {
+  InitializeMockStore();
+
+  // We've found this form on a website:
+  PasswordForm encountered_form;
+  encountered_form.origin = GURL("http://accounts.google.com/LoginAuth");
+  encountered_form.signon_realm = "http://accounts.google.com/";
+  encountered_form.action = GURL("http://accounts.google.com/Login");
+  encountered_form.username_element = ASCIIToUTF16("Email");
+  encountered_form.password_element = ASCIIToUTF16("Passwd");
+  encountered_form.submit_element = ASCIIToUTF16("signIn");
+
+  TestPasswordManagerClient client(profile(), mock_store());
+  MockPasswordManagerDriver driver;
+  EXPECT_CALL(driver, IsOffTheRecord()).WillRepeatedly(Return(false));
+  EXPECT_CALL(driver, AllowPasswordGenerationForForm(_));
+
+  TestPasswordManager manager(&client);
+  PasswordFormManager form_manager(&manager,
+                                   &client,
+                                   &driver,
+                                   encountered_form,
+                                   false);
+
+  const PasswordStore::AuthorizationPromptPolicy auth_policy =
+      PasswordStore::DISALLOW_PROMPT;
+  EXPECT_CALL(*mock_store(), GetLogins(encountered_form,
+                                       auth_policy,
+                                       &form_manager));
+  form_manager.FetchMatchingLoginsFromPasswordStore(auth_policy);
+
+  // Password store only has these incomplete credentials.
+  PasswordForm* incomplete_form = new PasswordForm();
+  incomplete_form->origin = GURL("http://accounts.google.com/LoginAuth");
+  incomplete_form->signon_realm = "http://accounts.google.com/";
+  incomplete_form->password_value = ASCIIToUTF16("my_password");
+  incomplete_form->username_value = ASCIIToUTF16("my_username");
+  incomplete_form->preferred = true;
+  incomplete_form->ssl_valid = false;
+  incomplete_form->scheme = PasswordForm::SCHEME_HTML;
+
+  // We expect to see this form eventually sent to the Password store. It
+  // has password/username values from the store and 'username_element',
+  // 'password_element', 'submit_element' and 'action' fields copied from
+  // the encountered form.
+  PasswordForm complete_form(*incomplete_form);
+  complete_form.action = encountered_form.action;
+  complete_form.password_element = encountered_form.password_element;
+  complete_form.username_element = encountered_form.username_element;
+  complete_form.submit_element = encountered_form.submit_element;
+
+  // Feed the incomplete credentials to the manager.
+  std::vector<PasswordForm*> results;
+  results.push_back(incomplete_form);  // Takes ownership.
+  form_manager.OnRequestDone(results);
+
+  form_manager.ProvisionallySave(
+        complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
+  // By now that form has been used once.
+  complete_form.times_used = 1;
+
+  // Check that PasswordStore receives an update request with the complete form.
+  EXPECT_CALL(*mock_store(), UpdateLogin(complete_form));
+  form_manager.Save();
+}