Kill WebDataService, move (WIN only) Password code into separate class.

chrome/browser/password_manager/password_store_win.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 "chrome/browser/password_manager/password_store_win.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/webdata/web_data_service.h"
+#include "chrome/browser/webdata/password_web_data_service_win.h"
 #include "components/os_crypt/ie7_password_win.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 using autofill::PasswordForm;
 using content::BrowserThread;
 using password_manager::PasswordStoreDefault;
 
-// Handles requests to WebDataService.
+// Handles requests to PasswordWebDataService.
 class PasswordStoreWin::DBHandler : public WebDataServiceConsumer {
  public:
-  DBHandler(WebDataService* web_data_service,
+  DBHandler(PasswordWebDataService* web_data_service,
             PasswordStoreWin* password_store)
       : web_data_service_(web_data_service),
         password_store_(password_store) {
   }
 
   ~DBHandler();
 
   // Requests the IE7 login for |form|. This is async. |callback_runner| will be
   // run when complete.
   void GetIE7Login(
       const PasswordForm& form,
       const PasswordStoreWin::ConsumerCallbackRunner& callback_runner);
 
  private:
   struct RequestInfo {
     RequestInfo() {}
 
     RequestInfo(PasswordForm* request_form,
                 const PasswordStoreWin::ConsumerCallbackRunner& runner)
         : form(request_form),
           callback_runner(runner) {}
 
     PasswordForm* form;
     PasswordStoreWin::ConsumerCallbackRunner callback_runner;
   };
 
   // Holds info associated with in-flight GetIE7Login requests.
-  typedef std::map<WebDataService::Handle, RequestInfo> PendingRequestMap;
+  typedef std::map<PasswordWebDataService::Handle, RequestInfo>
+      PendingRequestMap;
 
   // Gets logins from IE7 if no others are found. Also copies them into
   // Chrome's WebDatabase so we don't need to look next time.
   std::vector<autofill::PasswordForm*> GetIE7Results(
       const WDTypedResult* result,
       const PasswordForm& form);
 
   // WebDataServiceConsumer implementation.
   virtual void OnWebDataServiceRequestDone(
-      WebDataService::Handle handle,
+      PasswordWebDataService::Handle handle,
       const WDTypedResult* result) OVERRIDE;
 
-  scoped_refptr<WebDataService> web_data_service_;
+  scoped_refptr<PasswordWebDataService> web_data_service_;
 
   // This creates a cycle between us and PasswordStore. The cycle is broken
   // from PasswordStoreWin::Shutdown, which deletes us.
   scoped_refptr<PasswordStoreWin> password_store_;
 
   PendingRequestMap pending_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(DBHandler);
 };
 
 PasswordStoreWin::DBHandler::~DBHandler() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   for (PendingRequestMap::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end();
        ++i) {
     web_data_service_->CancelRequest(i->first);
     delete i->second.form;
   }
 }
 
 void PasswordStoreWin::DBHandler::GetIE7Login(
     const PasswordForm& form,
     const PasswordStoreWin::ConsumerCallbackRunner& callback_runner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   IE7PasswordInfo info;
   info.url_hash =
       ie7_password::GetUrlHash(base::UTF8ToWide(form.origin.spec()));
-  WebDataService::Handle handle = web_data_service_->GetIE7Login(info, this);
+  PasswordWebDataService::Handle handle =
+      web_data_service_->GetIE7Login(info, this);
   pending_requests_[handle] =
       RequestInfo(new PasswordForm(form), callback_runner);
 }
 
 std::vector<PasswordForm*> PasswordStoreWin::DBHandler::GetIE7Results(
     const WDTypedResult *result,
     const PasswordForm& form) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   std::vector<PasswordForm*> matching_forms;
 
@@ skipping 25 matching lines @@
         // Add this PasswordForm to the saved password table. We're on the DB
         // thread already, so we use AddLoginImpl.
         password_store_->AddLoginImpl(*autofill);
       }
     }
   }
   return matching_forms;
 }
 
 void PasswordStoreWin::DBHandler::OnWebDataServiceRequestDone(
-    WebDataService::Handle handle,
+    PasswordWebDataService::Handle handle,
     const WDTypedResult* result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   PendingRequestMap::iterator i = pending_requests_.find(handle);
   DCHECK(i != pending_requests_.end());
 
   scoped_ptr<PasswordForm> form(i->second.form);
   PasswordStoreWin::ConsumerCallbackRunner callback_runner(
       i->second.callback_runner);
   pending_requests_.erase(i);
 
   if (!result) {
     // The WDS returns NULL if it is shutting down. Run callback with empty
     // result.
     callback_runner.Run(std::vector<autofill::PasswordForm*>());
     return;
   }
 
   DCHECK_EQ(PASSWORD_IE7_RESULT, result->GetType());
   std::vector<autofill::PasswordForm*> matched_forms =
       GetIE7Results(result, *form);
 
   callback_runner.Run(matched_forms);
 }
 
 PasswordStoreWin::PasswordStoreWin(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
     password_manager::LoginDatabase* login_database,
-    WebDataService* web_data_service)
+    PasswordWebDataService* web_data_service)
     : PasswordStoreDefault(main_thread_runner,
                            db_thread_runner,
                            login_database) {
   db_handler_.reset(new DBHandler(web_data_service, this));
 }
 
 PasswordStoreWin::~PasswordStoreWin() {
 }
 
 void PasswordStoreWin::ShutdownOnDBThread() {
@@ skipping 23 matching lines @@
 
 void PasswordStoreWin::GetLoginsImpl(
     const PasswordForm& form,
     AuthorizationPromptPolicy prompt_policy,
     const ConsumerCallbackRunner& callback_runner) {
   ConsumerCallbackRunner get_ie7_login =
       base::Bind(&PasswordStoreWin::GetIE7LoginIfNecessary,
                  this, form, callback_runner);
   PasswordStoreDefault::GetLoginsImpl(form, prompt_policy, get_ie7_login);
 }