Introduce a couple of abstract bases for WebDataService.

chrome/browser/autofill/personal_data_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOFILL_PERSONAL_DATA_MANAGER_H_
 #define CHROME_BROWSER_AUTOFILL_PERSONAL_DATA_MANAGER_H_
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/credit_card.h"
 #include "chrome/browser/autofill/field_types.h"
+#include "chrome/browser/api/webdata/autofill_web_data_service.h"
+#include "chrome/browser/api/webdata/web_data_service_consumer.h"
+
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
-#include "chrome/browser/webdata/web_data_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class AutofillMetrics;
 class FormStructure;
 class PersonalDataManagerObserver;
 class Profile;
 
 namespace autofill_helper {
 void SetProfiles(int, std::vector<AutofillProfile>*);
 void SetCreditCards(int, std::vector<CreditCard>*);
 }
 
 // Handles loading and saving Autofill profile information to the web database.
 // This class also stores the profiles loaded from the database for use during
 // Autofill.
 class PersonalDataManager
     : public WebDataServiceConsumer,
       public ProfileSyncServiceObserver,
       public ProfileKeyedService,
       public content::NotificationObserver {
  public:
   // WebDataServiceConsumer:
   virtual void OnWebDataServiceRequestDone(
-      WebDataService::Handle h,
+      WebDataServiceBase::Handle h,
       const WDTypedResult* result) OVERRIDE;
 
   // Sets the listener to be notified of PersonalDataManager events.
   virtual void SetObserver(PersonalDataManagerObserver* observer);
 
   // Removes |observer| as the observer of this PersonalDataManager.
   virtual void RemoveObserver(PersonalDataManagerObserver* observer);
 
   // ProfileSyncServiceObserver:
   virtual void OnStateChanged() OVERRIDE;
 
   // ProfileKeyedService:
-  // Cancels any pending requests to WebDataService and stops listening for Sync
-  // notifications.
+  // Cancels any pending requests to WebDataServiceBase and stops
+  // listening for Sync notifications.
   virtual void Shutdown() OVERRIDE;
 
   // content::NotificationObserver:
   // Observes "batch" changes made by Sync and refreshes data from the
-  // WebDataService in response.
+  // WebDataServiceBase in response.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Scans the given |form| for importable Autofill data. If the form includes
   // sufficient address data, it is immediately imported. If the form includes
   // sufficient credit card data, it is stored into |credit_card|, so that we
   // can prompt the user whether to save this data.
   // Returns |true| if sufficient address or credit card data was found.
   bool ImportFormData(const FormStructure& form,
@@ skipping 106 matching lines @@
   virtual void LoadProfiles();
 
   // Loads the auxiliary profiles.  Currently Mac only.
   void LoadAuxiliaryProfiles() const;
 
   // Loads the saved credit cards from the web database.
   virtual void LoadCreditCards();
 
   // Receives the loaded profiles from the web data service and stores them in
   // |credit_cards_|.
-  void ReceiveLoadedProfiles(WebDataService::Handle h,
+  void ReceiveLoadedProfiles(WebDataServiceBase::Handle h,
                              const WDTypedResult* result);
 
   // Receives the loaded credit cards from the web data service and stores them
   // in |credit_cards_|.
-  void ReceiveLoadedCreditCards(WebDataService::Handle h,
+  void ReceiveLoadedCreditCards(WebDataServiceBase::Handle h,
                                 const WDTypedResult* result);
 
   // Cancels a pending query to the web database.  |handle| is a pointer to the
   // query handle.
-  void CancelPendingQuery(WebDataService::Handle* handle);
+  void CancelPendingQuery(WebDataServiceBase::Handle* handle);
 
   // Saves |imported_profile| to the WebDB if it exists.
   virtual void SaveImportedProfile(const AutofillProfile& imported_profile);
 
   // Notifies Sync about data migration if necessary.
   void EmptyMigrationTrash();
 
   // The first time this is called, logs an UMA metrics for the number of
   // profiles the user has. On subsequent calls, does nothing.
   void LogProfileCount() const;
@@ skipping 17 matching lines @@
   // Auxiliary profiles.
   mutable ScopedVector<AutofillProfile> auxiliary_profiles_;
 
   // Storage for combined web and auxiliary profiles.  Contents are weak
   // references.  Lifetime managed by |web_profiles_| and |auxiliary_profiles_|.
   mutable std::vector<AutofillProfile*> profiles_;
 
   // The loaded credit cards.
   ScopedVector<CreditCard> credit_cards_;
 
-  // When the manager makes a request from WebDataService, the database
+  // When the manager makes a request from WebDataServiceBase, the database
   // is queried on another thread, we record the query handle until we
   // get called back.  We store handles for both profile and credit card queries
   // so they can be loaded at the same time.
-  WebDataService::Handle pending_profiles_query_;
-  WebDataService::Handle pending_creditcards_query_;
+  WebDataServiceBase::Handle pending_profiles_query_;
+  WebDataServiceBase::Handle pending_creditcards_query_;
 
   // The observers.
   ObserverList<PersonalDataManagerObserver> observers_;
 
  private:
   // Kicks off asynchronous loading of profiles and credit cards.
   void Init(Profile* profile);
 
   // For logging UMA metrics. Overridden by metrics tests.
   scoped_ptr<const AutofillMetrics> metric_logger_;
 
   // Whether we have already logged the number of profiles this session.
   mutable bool has_logged_profile_count_;
 
   // Manages registration lifetime for NotificationObserver implementation.
   content::NotificationRegistrar notification_registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(PersonalDataManager);
 };
 
 #endif  // CHROME_BROWSER_AUTOFILL_PERSONAL_DATA_MANAGER_H_