Generate passwords only for forms that autofill server marks as account creation forms.

chrome/browser/password_manager/password_generation_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 <vector>
 
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/password_manager/password_generation_manager.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/password_manager/password_manager_delegate_impl.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/autofill/core/browser/autofill_field.h"
+#include "components/autofill/core/browser/form_structure.h"
+#include "components/autofill/core/common/form_data.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 class TestPasswordGenerationManager : public PasswordGenerationManager {
  public:
   explicit TestPasswordGenerationManager(content::WebContents* contents)
       : PasswordGenerationManager(contents) {}
   virtual ~TestPasswordGenerationManager() {}
 
   virtual void SendStateToRenderer(content::RenderViewHost* host,
                                    bool enabled) OVERRIDE {
     sent_states_.push_back(enabled);
   }
 
+  virtual void SendAccountCreationFormsToRenderer(
+      content::RenderViewHost* host,
+      const std::vector<GURL>& origins) OVERRIDE {
+    sent_account_creation_forms_.insert(
+        sent_account_creation_forms_.begin(), origins.begin(), origins.end());
+  }
+
   const std::vector<bool>& GetSentStates() {
     return sent_states_;
   }
 
+  const std::vector<GURL>& GetSentAccountCreationForms() {
+    return sent_account_creation_forms_;
+  }
+
   void ClearSentStates() {
     sent_states_.clear();
   }
 
+  void ClearSentAccountCreationForms() {
+    sent_account_creation_forms_.clear();
+  }
+
  private:
   std::vector<bool> sent_states_;
+  std::vector<GURL> sent_account_creation_forms_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPasswordGenerationManager);
 };
 
 class PasswordGenerationManagerTest : public ChromeRenderViewHostTestHarness {
  protected:
   virtual void SetUp() OVERRIDE {
     SetThreadBundleOptions(content::TestBrowserThreadBundle::REAL_IO_THREAD);
     ChromeRenderViewHostTestHarness::SetUp();
 
     password_generation_manager_.reset(
         new TestPasswordGenerationManager(web_contents()));
   }
 
   virtual void TearDown() OVERRIDE {
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   void UpdateState(bool new_renderer) {
     password_generation_manager_->UpdateState(NULL, new_renderer);
   }
 
+  void DetectAccountCreationForms(
+      const std::vector<autofill::FormStructure*>& forms) {
+    password_generation_manager_->DetectAccountCreationForms(forms);
+  }
+
   scoped_ptr<TestPasswordGenerationManager> password_generation_manager_;
 };
 
 class IncognitoPasswordGenerationManagerTest :
     public PasswordGenerationManagerTest {
  public:
   virtual content::BrowserContext* CreateBrowserContext() OVERRIDE {
     // Create an incognito profile.
     TestingProfile::Builder builder;
     scoped_ptr<TestingProfile> profile = builder.Build();
@@ skipping 101 matching lines @@
   password_generation_manager_->ClearSentStates();
 
   // When a new render_view is created, we send the state even if it's the
   // same.
   UpdateState(true);
   EXPECT_EQ(1u, password_generation_manager_->GetSentStates().size());
   EXPECT_FALSE(password_generation_manager_->GetSentStates()[0]);
   password_generation_manager_->ClearSentStates();
 }
 
+TEST_F(PasswordGenerationManagerTest, DetectAccountCreationForms) {
+  autofill::FormData data;
+  data.origin = GURL("http://www.yahoo.com/login/");
+  autofill::FormStructure form1(data, "");
+  autofill::AutofillField* field = new autofill::AutofillField();
+  field->set_server_type(autofill::EMAIL_ADDRESS);
+
+  form1.fields_.push_back(field);

[Garrett Casto, 2013/08/29 22:45:13]

You should probably construct a FormData and then create a FormStructure from
it. Not only will that remove the need for the friend declaration in
FormStructure, but it's closer to what actually happens. For instance, right now
FormStructure will never parse password forms because of
FormStructure::ShouldSkipField. Ideally I would also like a BrowserTest where we
mock out the servers response, navigate to a page, and make sure that we show
the icon. We don't need to do that in this CL though.

[zysxqn, 2013/09/03 23:00:20]

Done.

+  field = new autofill::AutofillField();
+  field->set_server_type(autofill::PASSWORD);
+  form1.fields_.push_back(field);
+  std::vector<autofill::FormStructure*> forms;
+  forms.push_back(&form1);
+  data.origin = GURL("http://accounts.yahoo.com/");
+  autofill::FormStructure form2(data, "");
+  field = new autofill::AutofillField();
+  field->set_server_type(autofill::EMAIL_ADDRESS);
+  form2.fields_.push_back(field);
+  field = new autofill::AutofillField();
+  field->set_server_type(autofill::ACCOUNT_CREATION_PASSWORD);
+  form2.fields_.push_back(field);
+  field = new autofill::AutofillField();
+  field->set_server_type(autofill::PASSWORD);
+  form2.fields_.push_back(field);
+  forms.push_back(&form2);
+
+  DetectAccountCreationForms(forms);
+  EXPECT_EQ(1u,
+            password_generation_manager_->GetSentAccountCreationForms().size());
+  EXPECT_EQ(GURL("http://accounts.yahoo.com/"),
+            password_generation_manager_->GetSentAccountCreationForms()[0]);
+}
+
 TEST_F(IncognitoPasswordGenerationManagerTest,
        UpdatePasswordSyncStateIncognito) {
   // Disable password manager by going incognito, and enable syncing. The
   // feature should still be disabled, and nothing will be sent.
   PasswordManagerDelegateImpl::CreateForWebContents(web_contents());
   PasswordManager::CreateForWebContentsAndDelegate(
       web_contents(),
       PasswordManagerDelegateImpl::FromWebContents(web_contents()));
 
   PrefService* prefs = profile()->GetPrefs();
 
   // Allow this test to control what should get synced.
   prefs->SetBoolean(prefs::kSyncKeepEverythingSynced, false);
   // Always set password generation enabled check box so we can test the
   // behavior of password sync.
   prefs->SetBoolean(prefs::kPasswordGenerationEnabled, true);
 
   browser_sync::SyncPrefs sync_prefs(profile()->GetPrefs());
   sync_prefs.SetSyncSetupCompleted();
   UpdateState(false);
   EXPECT_EQ(0u, password_generation_manager_->GetSentStates().size());
 }