Reverting 17273 - Fails reliability tests

chrome/browser/password_manager/password_form_manager.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/password_manager/password_form_manager.h"
 
 #include <algorithm>
 
 #include "base/string_util.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/profile.h"
 #include "webkit/glue/password_form_dom_manager.h"
 
 using base::Time;
 
 PasswordFormManager::PasswordFormManager(Profile* profile,
                                          PasswordManager* password_manager,
                                          const PasswordForm& observed_form,
                                          bool ssl_valid)
     : best_matches_deleter_(&best_matches_),
       observed_form_(observed_form),
       is_new_login_(true),
       password_manager_(password_manager),
-      pending_login_query_(0),
+      pending_login_query_(NULL),
       preferred_match_(NULL),
       state_(PRE_MATCHING_PHASE),
       profile_(profile) {
   DCHECK(profile_);
   if (observed_form_.origin.is_valid())
     SplitString(observed_form_.origin.path(), '/', &form_path_tokens_);
   observed_form_.ssl_valid = ssl_valid;
 }
 
 PasswordFormManager::~PasswordFormManager() {
@@ skipping 126 matching lines @@
   if (IsNewLogin())
     SaveAsNewLogin();
   else
     UpdateLogin();
 }
 
 void PasswordFormManager::FetchMatchingLoginsFromWebDatabase() {
   DCHECK_EQ(state_, PRE_MATCHING_PHASE);
   DCHECK(!pending_login_query_);
   state_ = MATCHING_PHASE;
-  PasswordStore* password_store =
-      profile_->GetPasswordStore(Profile::EXPLICIT_ACCESS);
-  if (!password_store) {
+  WebDataService* web_data_service =
+      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
+  if (!web_data_service) {
     NOTREACHED();
     return;
   }
-  pending_login_query_ = password_store->GetLogins(observed_form_, this);
+  pending_login_query_ = web_data_service->GetLogins(observed_form_, this);
 }
 
 bool PasswordFormManager::HasCompletedMatching() {
   return state_ == POST_MATCHING_PHASE;
 }
 
-void PasswordFormManager::OnRequestDone(int handle,
-    const std::vector<PasswordForm*>& logins_result) {
+void PasswordFormManager::OnRequestDone(WebDataService::Handle h,
+    const WDTypedResult* result) {
+  // Get the result from the database into a usable form.
+  const WDResult<std::vector<PasswordForm*> >* r =
+      static_cast<const WDResult<std::vector<PasswordForm*> >*>(result);
+  std::vector<PasswordForm*> logins_result = r->GetValue();
   // Note that the result gets deleted after this call completes, but we own
   // the PasswordForm objects pointed to by the result vector, thus we keep
   // copies to a minimum here.
 
   int best_score = 0;
   std::vector<PasswordForm> empties; // Empty-path matches in result set.
   for (size_t i = 0; i < logins_result.size(); i++) {
     if (IgnoreResult(*logins_result[i])) {
       delete logins_result[i];
       continue;
@@ skipping 32 matching lines @@
       best_matches_.clear();
       preferred_match_ = NULL;  // Don't delete, its owned by best_matches_.
       best_matches_[logins_result[i]->username_value] = logins_result[i];
     }
     preferred_match_ = logins_result[i]->preferred ? logins_result[i]
                                                    : preferred_match_;
   }
   // We're done matching now.
   state_ = POST_MATCHING_PHASE;
 
+  if (best_score <= 0) {
+#if defined(OS_WIN)
+    state_ = PRE_MATCHING_PHASE;
+    FetchMatchingIE7LoginFromWebDatabase();
+#endif
+    return;
+  }
+
   for (std::vector<PasswordForm>::const_iterator it = empties.begin();
        it != empties.end(); ++it) {
     // If we don't already have a result with the same username, add the
     // lower-scored empty-path match (if it had equal score it would already be
     // in best_matches_).
     if (best_matches_.find(it->username_value) == best_matches_.end())
       best_matches_[it->username_value] = new PasswordForm(*it);
   }
 
   // Its possible we have at least one match but have no preferred_match_,
   // because a user may have chosen to 'Forget' the preferred match. So we
   // just pick the first one and whichever the user selects for submit will
   // be saved as preferred.
   DCHECK(!best_matches_.empty());
   if (!preferred_match_)
     preferred_match_ = best_matches_.begin()->second;
 
   // Now we determine if the user told us to ignore this site in the past.
   // If they haven't, we proceed to auto-fill.
   if (!preferred_match_->blacklisted_by_user) {
     password_manager_->Autofill(observed_form_, best_matches_,
                                 preferred_match_);
   }
 }
 
-void PasswordFormManager::OnPasswordStoreRequestDone(
-    int handle, const std::vector<PasswordForm*>& result) {
+void PasswordFormManager::OnWebDataServiceRequestDone(WebDataService::Handle h,
+    const WDTypedResult* result) {
   DCHECK_EQ(state_, MATCHING_PHASE);
-  DCHECK_EQ(pending_login_query_, handle);
+  DCHECK_EQ(pending_login_query_, h);
+  DCHECK(result);
+  pending_login_query_ = NULL;
 
-  if (result.empty()) {
-    state_ = POST_MATCHING_PHASE;
+  if (!result)
     return;
+
+  switch (result->GetType()) {
+    case PASSWORD_RESULT: {
+      OnRequestDone(h, result);
+      break;
+    }
+#if defined(OS_WIN)
+    case PASSWORD_IE7_RESULT: {
+      OnIE7RequestDone(h, result);
+      break;
+    }
+#endif
+    default:
+      NOTREACHED();
   }
-
-  OnRequestDone(handle, result);
 }
 
 bool PasswordFormManager::IgnoreResult(const PasswordForm& form) const {
   // Ignore change password forms until we have some change password
   // functionality
   if (observed_form_.old_password_element.length() != 0) {
     return true;
   }
   // Don't match an invalid SSL form with one saved under secure
   // circumstances.
   if (form.ssl_valid && !observed_form_.ssl_valid) {
     return true;
   }
   return false;
 }
 
 void PasswordFormManager::SaveAsNewLogin() {
   DCHECK_EQ(state_, POST_MATCHING_PHASE);
   DCHECK(IsNewLogin());
   // The new_form is being used to sign in, so it is preferred.
   DCHECK(pending_credentials_.preferred);
   // new_form contains the same basic data as observed_form_ (because its the
   // same form), but with the newly added credentials.
 
   DCHECK(!profile_->IsOffTheRecord());
 
-  PasswordStore* password_store =
-      profile_->GetPasswordStore(Profile::IMPLICIT_ACCESS);
-  if (!password_store) {
+  WebDataService* web_data_service =
+      profile_->GetWebDataService(Profile::IMPLICIT_ACCESS);
+  if (!web_data_service) {
     NOTREACHED();
     return;
   }
-
   pending_credentials_.date_created = Time::Now();
-  password_store->AddLogin(pending_credentials_);
+  web_data_service->AddLogin(pending_credentials_);
 }
 
 void PasswordFormManager::UpdateLogin() {
   DCHECK_EQ(state_, POST_MATCHING_PHASE);
   DCHECK(preferred_match_);
   // If we're doing an Update, its because we autofilled a form and the user
   // submitted it with a possibly new password value, page security, or selected
   // one of the non-preferred matches, thus requiring a swap of preferred bits.
   DCHECK(!IsNewLogin() && pending_credentials_.preferred);
   DCHECK(!profile_->IsOffTheRecord());
 
-  PasswordStore* password_store =
-      profile_->GetPasswordStore(Profile::IMPLICIT_ACCESS);
-  if (!password_store) {
+  WebDataService* web_data_service =
+      profile_->GetWebDataService(Profile::IMPLICIT_ACCESS);
+  if (!web_data_service) {
     NOTREACHED();
     return;
   }
 
   // Update all matches to reflect new preferred status.
   PasswordFormMap::iterator iter;
   for (iter = best_matches_.begin(); iter != best_matches_.end(); iter++) {
     if ((iter->second->username_value != pending_credentials_.username_value) &&
          iter->second->preferred) {
       // This wasn't the selected login but it used to be preferred.
       iter->second->preferred = false;
-      password_store->UpdateLogin(*iter->second);
+      web_data_service->UpdateLogin(*iter->second);
     }
   }
   // Update the new preferred login.
   // Note origin.spec().length > signon_realm.length implies the origin has a
   // path, since signon_realm is a prefix of origin for HTML password forms.
   if ((observed_form_.scheme == PasswordForm::SCHEME_HTML) &&
       (observed_form_.origin.spec().length() >
        observed_form_.signon_realm.length()) &&
       (observed_form_.signon_realm == pending_credentials_.origin.spec())) {
     // The user logged in successfully with one of our autofilled logins on a
     // page with non-empty path, but the autofilled entry was initially saved/
     // imported with an empty path. Rather than just mark this entry preferred,
     // we create a more specific copy for this exact page and leave the "master"
     // unchanged. This is to prevent the case where that master login is used
     // on several sites (e.g site.com/a and site.com/b) but the user actually
     // has a different preference on each site. For example, on /a, he wants the
     // general empty-path login so it is flagged as preferred, but on /b he logs
     // in with a different saved entry - we don't want to remove the preferred
     // status of the former because upon return to /a it won't be the default-
     // fill match.
     // TODO(timsteele): Bug 1188626 - expire the master copies.
     PasswordForm copy(pending_credentials_);
     copy.origin = observed_form_.origin;
     copy.action = observed_form_.action;
-    password_store->AddLogin(copy);
+    web_data_service->AddLogin(copy);
   } else {
-    password_store->UpdateLogin(pending_credentials_);
+    web_data_service->UpdateLogin(pending_credentials_);
   }
 }
 
 void PasswordFormManager::CancelLoginsQuery() {
-  PasswordStore* password_store =
-      profile_->GetPasswordStore(Profile::IMPLICIT_ACCESS);
-  if (!password_store) {
-    // Can be NULL in unit tests.
+  if (!pending_login_query_)
+    return;
+  WebDataService* web_data_service =
+      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
+  if (!web_data_service) {
+    NOTREACHED();
     return;
   }
-  password_store->CancelLoginsQuery(pending_login_query_);
+  web_data_service->CancelRequest(pending_login_query_);
+  pending_login_query_ = NULL;
 }
 
 int PasswordFormManager::ScoreResult(const PasswordForm& candidate) const {
   DCHECK_EQ(state_, MATCHING_PHASE);
   // For scoring of candidate login data:
   // The most important element that should match is the origin, followed by
   // the action, the password name, the submit button name, and finally the
   // username input field name.
   // Exact origin match gives an addition of 32 (1 << 5) + # of matching url
   // dirs.
@@ skipping 30 matching lines @@
     if (candidate.password_element == observed_form_.password_element)
       score += 1 << 2;
     if (candidate.submit_element == observed_form_.submit_element)
       score += 1 << 1;
     if (candidate.username_element == observed_form_.username_element)
       score += 1 << 0;
   }
 
   return score;
 }