Separate WebDataRequest functionality from WebDataService

chrome/browser/webdata/web_data_service.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/webdata/web_data_service.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
@@ skipping 62 matching lines @@
 WDKeywordsResult::WDKeywordsResult()
   : default_search_provider_id(0),
     builtin_keyword_version(0) {
 }
 
 WDKeywordsResult::~WDKeywordsResult() {}
 
 WebDataService::WebDataService()
     : is_running_(false),
       db_(NULL),
+      request_manager_(new WebDataRequestManager()),
       autocomplete_syncable_service_(NULL),
       autofill_profile_syncable_service_(NULL),
       failed_init_(false),
       should_commit_(false),
-      next_request_handle_(1),
       main_loop_(MessageLoop::current()) {
   // WebDataService requires DB thread if instantiated.
   // Set WebDataServiceFactory::GetInstance()->SetTestingFactory(&profile, NULL)
   // if you do not want to instantiate WebDataService in your test.
   DCHECK(BrowserThread::IsWellKnownThread(BrowserThread::DB));
 }
 
 // static
 void WebDataService::NotifyOfMultipleAutofillChanges(
     WebDataService* web_data_service) {
@@ skipping 22 matching lines @@
 
 bool WebDataService::IsRunning() const {
   return is_running_;
 }
 
 void WebDataService::UnloadDatabase() {
   ScheduleTask(FROM_HERE, Bind(&WebDataService::ShutdownDatabase, this));
 }
 
 void WebDataService::CancelRequest(Handle h) {
-  base::AutoLock l(pending_lock_);
-  RequestMap::iterator i = pending_requests_.find(h);
-  if (i == pending_requests_.end()) {
-    NOTREACHED() << "Canceling a nonexistent web data service request";
-    return;
-  }
-  i->second->Cancel();
+  request_manager_->CancelRequest(h);
 }
 
 content::NotificationSource WebDataService::GetNotificationSource() {
   return content::Source<WebDataService>(this);
 }
 
 bool WebDataService::IsDatabaseLoaded() {
   return db_ != NULL;
 }
 
 WebDatabase* WebDataService::GetDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   return db_;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Keywords.
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddKeyword(const TemplateURLData& data) {
   GenericRequest<TemplateURLData>* request =
-      new GenericRequest<TemplateURLData>(this, GetNextRequestHandle(), NULL,
-                                          data);
-  RegisterRequest(request);
+      new GenericRequest<TemplateURLData>(
+          this, NULL, request_manager_, data);
   ScheduleTask(FROM_HERE, Bind(&WebDataService::AddKeywordImpl, this, request));
 }
 
 void WebDataService::RemoveKeyword(TemplateURLID id) {
   GenericRequest<TemplateURLID>* request =
-      new GenericRequest<TemplateURLID>(this, GetNextRequestHandle(), NULL, id);
-  RegisterRequest(request);
+      new GenericRequest<TemplateURLID>(this, NULL, request_manager_, id);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveKeywordImpl, this, request));
 }
 
 void WebDataService::UpdateKeyword(const TemplateURLData& data) {
   GenericRequest<TemplateURLData>* request =
-      new GenericRequest<TemplateURLData>(this, GetNextRequestHandle(), NULL,
-                                          data);
-  RegisterRequest(request);
+      new GenericRequest<TemplateURLData>(
+          this, NULL, request_manager_, data);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::UpdateKeywordImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetKeywords(
                                        WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
-      new WebDataRequest(this, GetNextRequestHandle(), consumer);
-  RegisterRequest(request);
+      new WebDataRequest(this, consumer, request_manager_);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetKeywordsImpl, this, request));
   return request->GetHandle();
 }
 
 void WebDataService::SetDefaultSearchProvider(const TemplateURL* url) {
   GenericRequest<TemplateURLID>* request = new GenericRequest<TemplateURLID>(
-      this, GetNextRequestHandle(), NULL, url ? url->id() : 0);
-  RegisterRequest(request);
+      this, NULL, request_manager_, url ? url->id() : 0);
   ScheduleTask(FROM_HERE, Bind(&WebDataService::SetDefaultSearchProviderImpl,
                                this, request));
 }
 
 void WebDataService::SetBuiltinKeywordVersion(int version) {
-  GenericRequest<int>* request =
-      new GenericRequest<int>(this, GetNextRequestHandle(), NULL, version);
-  RegisterRequest(request);
+  GenericRequest<int>* request = new GenericRequest<int>(
+      this, NULL, request_manager_, version);
   ScheduleTask(FROM_HERE, Bind(&WebDataService::SetBuiltinKeywordVersionImpl,
                                this, request));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Web Apps
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::SetWebAppImage(const GURL& app_url,
                                     const SkBitmap& image) {
   GenericRequest2<GURL, SkBitmap>* request =
-      new GenericRequest2<GURL, SkBitmap>(this, GetNextRequestHandle(),
-                                         NULL, app_url, image);
-  RegisterRequest(request);
+      new GenericRequest2<GURL, SkBitmap>(
+          this, NULL, request_manager_, app_url, image);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::SetWebAppImageImpl, this, request));
 }
 
 void WebDataService::SetWebAppHasAllImages(const GURL& app_url,
                                            bool has_all_images) {
   GenericRequest2<GURL, bool>* request =
-      new GenericRequest2<GURL, bool>(this, GetNextRequestHandle(),
-                                     NULL, app_url, has_all_images);
-  RegisterRequest(request);
+      new GenericRequest2<GURL, bool>(
+          this, NULL, request_manager_, app_url, has_all_images);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::SetWebAppHasAllImagesImpl, this, request));
 }
 
 void WebDataService::RemoveWebApp(const GURL& app_url) {
   GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(this, GetNextRequestHandle(), NULL, app_url);
-  RegisterRequest(request);
+      new GenericRequest<GURL>(this, NULL, request_manager_, app_url);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveWebAppImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetWebAppImages(
     const GURL& app_url,
     WebDataServiceConsumer* consumer) {
   GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(this, GetNextRequestHandle(), consumer, app_url);
-  RegisterRequest(request);
+      new GenericRequest<GURL>(this, consumer, request_manager_, app_url);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetWebAppImagesImpl, this, request));
   return request->GetHandle();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Web Intents.
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddWebIntentService(const WebIntentServiceData& service) {
   GenericRequest<WebIntentServiceData>* request =
       new GenericRequest<WebIntentServiceData>(
-          this, GetNextRequestHandle(), NULL, service);
-  RegisterRequest(request);
+          this, NULL, request_manager_, service);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::AddWebIntentServiceImpl, this, request));
 }
 
 void WebDataService::RemoveWebIntentService(
     const WebIntentServiceData& service) {
   GenericRequest<WebIntentServiceData>* request =
       new GenericRequest<WebIntentServiceData>(
-          this, GetNextRequestHandle(), NULL, service);
-  RegisterRequest(request);
+          this, NULL, request_manager_, service);
   ScheduleTask(FROM_HERE, Bind(&WebDataService::RemoveWebIntentServiceImpl,
                                this, request));
 }
 
 WebDataService::Handle WebDataService::GetWebIntentServicesForAction(
     const string16& action,
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
-  GenericRequest<string16>* request = new GenericRequest<string16>(
-      this, GetNextRequestHandle(), consumer, action);
-  RegisterRequest(request);
+  GenericRequest<string16>* request =
+      new GenericRequest<string16>(
+          this, consumer, request_manager_, action);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetWebIntentServicesImpl, this, request));
   return request->GetHandle();
 }
 
 WebDataService::Handle WebDataService::GetWebIntentServicesForURL(
     const string16& service_url,
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
-  GenericRequest<string16>* request = new GenericRequest<string16>(
-          this, GetNextRequestHandle(), consumer, service_url);
-  RegisterRequest(request);
+  GenericRequest<string16>* request =
+      new GenericRequest<string16>(
+          this, consumer, request_manager_, service_url);
   ScheduleTask(FROM_HERE, Bind(&WebDataService::GetWebIntentServicesForURLImpl,
                                this, request));
   return request->GetHandle();
 }
 
 
 WebDataService::Handle WebDataService::GetAllWebIntentServices(
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
-  GenericRequest<std::string>* request = new GenericRequest<std::string>(
-      this, GetNextRequestHandle(), consumer, std::string());
-  RegisterRequest(request);
+  GenericRequest<std::string>* request =
+      new GenericRequest<std::string>(
+          this, consumer, request_manager_, std::string());
   ScheduleTask(FROM_HERE, Bind(&WebDataService::GetAllWebIntentServicesImpl,
                                this, request));
   return request->GetHandle();
 }
 
 void WebDataService::AddDefaultWebIntentService(
     const DefaultWebIntentService& service) {
   GenericRequest<DefaultWebIntentService>* request =
       new GenericRequest<DefaultWebIntentService>(
-          this, GetNextRequestHandle(), NULL, service);
-  RegisterRequest(request);
+          this, NULL, request_manager_, service);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::AddDefaultWebIntentServiceImpl, this,
                     request));
 }
 
 void WebDataService::RemoveDefaultWebIntentService(
     const DefaultWebIntentService& service) {
   GenericRequest<DefaultWebIntentService>* request =
       new GenericRequest<DefaultWebIntentService>(
-          this, GetNextRequestHandle(), NULL, service);
-  RegisterRequest(request);
+          this, NULL, request_manager_, service);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveDefaultWebIntentServiceImpl, this,
                     request));
 }
 
 void WebDataService::RemoveWebIntentServiceDefaults(
     const GURL& service_url) {
   GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(
-          this, GetNextRequestHandle(), NULL, service_url);
-  RegisterRequest(request);
+      new GenericRequest<GURL>(this, NULL, request_manager_, service_url);
   ScheduleTask(
       FROM_HERE,
       Bind(&WebDataService::RemoveWebIntentServiceDefaultsImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetDefaultWebIntentServicesForAction(
     const string16& action,
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
   GenericRequest<string16>* request = new GenericRequest<string16>(
-          this, GetNextRequestHandle(), consumer, action);
-  RegisterRequest(request);
+      this, consumer, request_manager_, action);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetDefaultWebIntentServicesForActionImpl,
                     this, request));
   return request->GetHandle();
 }
 
 WebDataService::Handle WebDataService::GetAllDefaultWebIntentServices(
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
   GenericRequest<std::string>* request = new GenericRequest<std::string>(
-      this, GetNextRequestHandle(), consumer, std::string());
-  RegisterRequest(request);
+      this, consumer, request_manager_, std::string());
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetAllDefaultWebIntentServicesImpl,
                     this, request));
   return request->GetHandle();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Token Service
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::SetTokenForService(const std::string& service,
                                         const std::string& token) {
   GenericRequest2<std::string, std::string>* request =
       new GenericRequest2<std::string, std::string>(
-          this, GetNextRequestHandle(), NULL, service, token);
-  RegisterRequest(request);
+          this, NULL, request_manager_, service, token);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::SetTokenForServiceImpl, this, request));
 }
 
 void WebDataService::RemoveAllTokens() {
   GenericRequest<std::string>* request =
       new GenericRequest<std::string>(
-          this, GetNextRequestHandle(), NULL, std::string());
-  RegisterRequest(request);
+          this, NULL, request_manager_, std::string());
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveAllTokensImpl, this, request));
 }
 
 // Null on failure. Success is WDResult<std::string>
 WebDataService::Handle WebDataService::GetAllTokens(
     WebDataServiceConsumer* consumer) {
 
   GenericRequest<std::string>* request =
       new GenericRequest<std::string>(
-          this, GetNextRequestHandle(), consumer, std::string());
-  RegisterRequest(request);
+          this, consumer, request_manager_, std::string());
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetAllTokensImpl, this, request));
   return request->GetHandle();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Autofill.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddFormFields(
     const std::vector<FormFieldData>& fields) {
   GenericRequest<std::vector<FormFieldData> >* request =
       new GenericRequest<std::vector<FormFieldData> >(
-          this, GetNextRequestHandle(), NULL, fields);
-  RegisterRequest(request);
+          this, NULL, request_manager_, fields);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::AddFormElementsImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetFormValuesForElementName(
     const string16& name, const string16& prefix, int limit,
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
-      new WebDataRequest(this, GetNextRequestHandle(), consumer);
-  RegisterRequest(request);
+      new WebDataRequest(this, consumer, request_manager_);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetFormValuesForElementNameImpl,
                     this, request, name, prefix, limit));
   return request->GetHandle();
 }
 
 void WebDataService::RemoveFormElementsAddedBetween(const Time& delete_begin,
                                                     const Time& delete_end) {
   GenericRequest2<Time, Time>* request =
-    new GenericRequest2<Time, Time>(this,
-                                    GetNextRequestHandle(),
-                                    NULL,
-                                    delete_begin,
-                                    delete_end);
-  RegisterRequest(request);
+    new GenericRequest2<Time, Time>(
+        this, NULL, request_manager_, delete_begin, delete_end);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveFormElementsAddedBetweenImpl,
                     this, request));
 }
 
 void WebDataService::RemoveExpiredFormElements() {
   WebDataRequest* request =
-      new WebDataRequest(this, GetNextRequestHandle(), NULL);
-  RegisterRequest(request);
+      new WebDataRequest(this, NULL, request_manager_);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveExpiredFormElementsImpl,
                     this, request));
 }
 
 void WebDataService::RemoveFormValueForElementName(
     const string16& name, const string16& value) {
   GenericRequest2<string16, string16>* request =
-      new GenericRequest2<string16, string16>(this,
-                                              GetNextRequestHandle(),
-                                              NULL,
-                                              name, value);
-  RegisterRequest(request);
+      new GenericRequest2<string16, string16>(
+          this, NULL, request_manager_, name, value);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveFormValueForElementNameImpl,
                     this, request));
 }
 
 void WebDataService::AddAutofillProfile(const AutofillProfile& profile) {
   GenericRequest<AutofillProfile>* request =
       new GenericRequest<AutofillProfile>(
-          this, GetNextRequestHandle(), NULL, profile);
-  RegisterRequest(request);
+          this, NULL, request_manager_, profile);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::AddAutofillProfileImpl, this, request));
 }
 
 void WebDataService::UpdateAutofillProfile(const AutofillProfile& profile) {
   GenericRequest<AutofillProfile>* request =
       new GenericRequest<AutofillProfile>(
-          this, GetNextRequestHandle(), NULL, profile);
-  RegisterRequest(request);
+          this, NULL, request_manager_, profile);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::UpdateAutofillProfileImpl, this, request));
 }
 
 void WebDataService::RemoveAutofillProfile(const std::string& guid) {
   GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(
-          this, GetNextRequestHandle(), NULL, guid);
-  RegisterRequest(request);
+      new GenericRequest<std::string>(this, NULL, request_manager_, guid);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveAutofillProfileImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetAutofillProfiles(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
-      new WebDataRequest(this, GetNextRequestHandle(), consumer);
-  RegisterRequest(request);
+    new WebDataRequest(this, consumer, request_manager_);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetAutofillProfilesImpl, this, request));
   return request->GetHandle();
 }
 
 void WebDataService::EmptyMigrationTrash(bool notify_sync) {
   GenericRequest<bool>* request =
-      new GenericRequest<bool>(
-          this, GetNextRequestHandle(), NULL, notify_sync);
-  RegisterRequest(request);
+      new GenericRequest<bool>(this, NULL, request_manager_, notify_sync);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::EmptyMigrationTrashImpl, this, request));
 }
 
 void WebDataService::AddCreditCard(const CreditCard& credit_card) {
   GenericRequest<CreditCard>* request =
       new GenericRequest<CreditCard>(
-          this, GetNextRequestHandle(), NULL, credit_card);
-  RegisterRequest(request);
+          this, NULL, request_manager_, credit_card);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::AddCreditCardImpl, this, request));
 }
 
 void WebDataService::UpdateCreditCard(const CreditCard& credit_card) {
   GenericRequest<CreditCard>* request =
       new GenericRequest<CreditCard>(
-          this, GetNextRequestHandle(), NULL, credit_card);
-  RegisterRequest(request);
+          this, NULL, request_manager_, credit_card);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::UpdateCreditCardImpl, this, request));
 }
 
 void WebDataService::RemoveCreditCard(const std::string& guid) {
   GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(
-          this, GetNextRequestHandle(), NULL, guid);
-  RegisterRequest(request);
+      new GenericRequest<std::string>(this, NULL, request_manager_, guid);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::RemoveCreditCardImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetCreditCards(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
-      new WebDataRequest(this, GetNextRequestHandle(), consumer);
-  RegisterRequest(request);
+      new WebDataRequest(this, consumer, request_manager_);
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::GetCreditCardsImpl, this, request));
   return request->GetHandle();
 }
 
 void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end) {
   GenericRequest2<Time, Time>* request =
-      new GenericRequest2<Time, Time>(this,
-                                      GetNextRequestHandle(),
-                                      NULL,
-                                      delete_begin,
-                                      delete_end);
-  RegisterRequest(request);
+      new GenericRequest2<Time, Time>(
+          this, NULL, request_manager_, delete_begin, delete_end);
   ScheduleTask(FROM_HERE, Bind(
       &WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl,
       this, request));
 }
 
 WebDataService::~WebDataService() {
   if (is_running_ && db_) {
     DLOG_ASSERT("WebDataService dtor called without Shutdown");
     NOTREACHED();
   }
@@ skipping 12 matching lines @@
     AutofillCountry::ApplicationLocale();
 
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::InitializeDatabaseIfNecessary, this));
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::InitializeSyncableServices, this));
   return true;
 }
 
 void WebDataService::RequestCompleted(Handle h) {
-  pending_lock_.Acquire();
-  RequestMap::iterator i = pending_requests_.find(h);
-  if (i == pending_requests_.end()) {
-    NOTREACHED() << "Request completed called for an unknown request";
-    pending_lock_.Release();
-    return;
-  }
-
-  // Take ownership of the request object and remove it from the map.
-  scoped_ptr<WebDataRequest> request(i->second);
-  pending_requests_.erase(i);
-  pending_lock_.Release();
-
-  // Notify the consumer if needed.
-  WebDataServiceConsumer* consumer = NULL;
-  if (!request->IsCancelled(&consumer) && consumer) {
-    consumer->OnWebDataServiceRequestDone(request->GetHandle(),
-                                          request->GetResult());
-  } else {
-    // Nobody is taken ownership of the result, either because it is cancelled
-    // or there is no consumer. Destroy results that require special handling.
-    WDTypedResult const *result = request->GetResult();
-    if (result) {
-      if (result->GetType() == AUTOFILL_PROFILES_RESULT) {
-        const WDResult<std::vector<AutofillProfile*> >* r =
-            static_cast<const WDResult<std::vector<AutofillProfile*> >*>(
-                result);
-        std::vector<AutofillProfile*> profiles = r->GetValue();
-        STLDeleteElements(&profiles);
-      } else if (result->GetType() == AUTOFILL_CREDITCARDS_RESULT) {
-        const WDResult<std::vector<CreditCard*> >* r =
-            static_cast<const WDResult<std::vector<CreditCard*> >*>(result);
-
-        std::vector<CreditCard*> credit_cards = r->GetValue();
-        STLDeleteElements(&credit_cards);
-      }
-    }
-  }
-}
-
-void WebDataService::RegisterRequest(WebDataRequest* request) {
-  base::AutoLock l(pending_lock_);
-  pending_requests_[request->GetHandle()] = request;
+  request_manager_->RequestCompleted(h);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // The following methods are executed in Chrome_WebDataThread.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::DBInitFailed(sql::InitStatus init_status) {
   ShowProfileErrorDialog(
@@ skipping 86 matching lines @@
     NOTREACHED() << "Task scheduled after Shutdown()";
 }
 
 void WebDataService::ScheduleCommit() {
   if (should_commit_ == false) {
     should_commit_ = true;
     ScheduleTask(FROM_HERE, Bind(&WebDataService::Commit, this));
   }
 }
 
-int WebDataService::GetNextRequestHandle() {
-  base::AutoLock l(pending_lock_);
-  return ++next_request_handle_;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Keywords implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddKeywordImpl(GenericRequest<TemplateURLData>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     db_->GetKeywordTable()->AddKeyword(request->arg());
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveKeywordImpl(GenericRequest<TemplateURLID>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     DCHECK(request->arg());
     db_->GetKeywordTable()->RemoveKeyword(request->arg());
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::UpdateKeywordImpl(
     GenericRequest<TemplateURLData>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     if (!db_->GetKeywordTable()->UpdateKeyword(request->arg())) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetKeywordsImpl(WebDataRequest* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     WDKeywordsResult result;
     db_->GetKeywordTable()->GetKeywords(&result.keywords);
     result.default_search_provider_id =
         db_->GetKeywordTable()->GetDefaultSearchProviderID();
     result.builtin_keyword_version =
         db_->GetKeywordTable()->GetBuiltinKeywordVersion();
     request->SetResult(
         new WDResult<WDKeywordsResult>(KEYWORDS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 void WebDataService::SetDefaultSearchProviderImpl(
     GenericRequest<TemplateURLID>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     if (!db_->GetKeywordTable()->SetDefaultSearchProviderID(request->arg())) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::SetBuiltinKeywordVersionImpl(
     GenericRequest<int>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     if (!db_->GetKeywordTable()->SetBuiltinKeywordVersion(request->arg())) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Web Apps implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::SetWebAppImageImpl(
     GenericRequest2<GURL, SkBitmap>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     db_->GetWebAppsTable()->SetWebAppImage(
         request->arg1(), request->arg2());
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::SetWebAppHasAllImagesImpl(
     GenericRequest2<GURL, bool>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     db_->GetWebAppsTable()->SetWebAppHasAllImages(request->arg1(),
                                                   request->arg2());
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveWebAppImpl(GenericRequest<GURL>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     db_->GetWebAppsTable()->RemoveWebApp(request->arg());
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetWebAppImagesImpl(GenericRequest<GURL>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     WDAppImagesResult result;
     result.has_all_images =
         db_->GetWebAppsTable()->GetWebAppHasAllImages(request->arg());
     db_->GetWebAppsTable()->GetWebAppImages(request->arg(), &result.images);
     request->SetResult(
         new WDResult<WDAppImagesResult>(WEB_APP_IMAGES, result));
   }
   request->RequestComplete();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Web Intents implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::RemoveWebIntentServiceImpl(
     GenericRequest<WebIntentServiceData>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const WebIntentServiceData& service = request->arg();
     db_->GetWebIntentsTable()->RemoveWebIntentService(service);
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::AddWebIntentServiceImpl(
     GenericRequest<WebIntentServiceData>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const WebIntentServiceData& service = request->arg();
     db_->GetWebIntentsTable()->SetWebIntentService(service);
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 
 void WebDataService::GetWebIntentServicesImpl(
     GenericRequest<string16>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<WebIntentServiceData> result;
     db_->GetWebIntentsTable()->GetWebIntentServicesForAction(request->arg(),
                                                              &result);
     request->SetResult(new WDResult<std::vector<WebIntentServiceData> >(
         WEB_INTENTS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetWebIntentServicesForURLImpl(
     GenericRequest<string16>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<WebIntentServiceData> result;
     db_->GetWebIntentsTable()->GetWebIntentServicesForURL(
         request->arg(), &result);
     request->SetResult(
         new WDResult<std::vector<WebIntentServiceData> >(
             WEB_INTENTS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetAllWebIntentServicesImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<WebIntentServiceData> result;
     db_->GetWebIntentsTable()->GetAllWebIntentServices(&result);
     request->SetResult(
         new WDResult<std::vector<WebIntentServiceData> >(
             WEB_INTENTS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 void WebDataService::AddDefaultWebIntentServiceImpl(
     GenericRequest<DefaultWebIntentService>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const DefaultWebIntentService& service = request->arg();
     db_->GetWebIntentsTable()->SetDefaultService(service);
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveDefaultWebIntentServiceImpl(
     GenericRequest<DefaultWebIntentService>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const DefaultWebIntentService& service = request->arg();
     db_->GetWebIntentsTable()->RemoveDefaultService(service);
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveWebIntentServiceDefaultsImpl(
     GenericRequest<GURL>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const GURL& service_url = request->arg();
     db_->GetWebIntentsTable()->RemoveServiceDefaults(service_url);
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetDefaultWebIntentServicesForActionImpl(
     GenericRequest<string16>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<DefaultWebIntentService> result;
     db_->GetWebIntentsTable()->GetDefaultServices(
         request->arg(), &result);
     request->SetResult(
         new WDResult<std::vector<DefaultWebIntentService> >(
             WEB_INTENTS_DEFAULTS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetAllDefaultWebIntentServicesImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<DefaultWebIntentService> result;
     db_->GetWebIntentsTable()->GetAllDefaultServices(&result);
     request->SetResult(
         new WDResult<std::vector<DefaultWebIntentService> >(
             WEB_INTENTS_DEFAULTS_RESULT, result));
   }
   request->RequestComplete();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Token Service implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // argument std::string is unused
 void WebDataService::RemoveAllTokensImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     if (db_->GetTokenServiceTable()->RemoveAllTokens()) {
       ScheduleCommit();
     }
   }
   request->RequestComplete();
 }
 
 void WebDataService::SetTokenForServiceImpl(
     GenericRequest2<std::string, std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     if (db_->GetTokenServiceTable()->SetTokenForService(
             request->arg1(), request->arg2())) {
       ScheduleCommit();
     }
   }
   request->RequestComplete();
 }
 
 // argument is unused
 void WebDataService::GetAllTokensImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::map<std::string, std::string> map;
     db_->GetTokenServiceTable()->GetAllTokens(&map);
     request->SetResult(
         new WDResult<std::map<std::string, std::string> >(TOKEN_RESULT, map));
   }
   request->RequestComplete();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Autofill implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddFormElementsImpl(
     GenericRequest<std::vector<FormFieldData> >* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     AutofillChangeList changes;
     if (!db_->GetAutofillTable()->AddFormFieldValues(
             request->arg(), &changes)) {
       NOTREACHED();
       return;
     }
     request->SetResult(
         new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes));
     ScheduleCommit();
 
     // Post the notifications including the list of affected keys.
     // This is sent here so that work resulting from this notification will be
     // done on the DB thread, and not the UI thread.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillChangeList>(&changes));
   }
 
   request->RequestComplete();
 }
 
 void WebDataService::GetFormValuesForElementNameImpl(WebDataRequest* request,
     const string16& name, const string16& prefix, int limit) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<string16> values;
     db_->GetAutofillTable()->GetFormValuesForElementName(
         name, prefix, &values, limit);
     request->SetResult(
         new WDResult<std::vector<string16> >(AUTOFILL_VALUE_RESULT, values));
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveFormElementsAddedBetweenImpl(
     GenericRequest2<Time, Time>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     AutofillChangeList changes;
     if (db_->GetAutofillTable()->RemoveFormElementsAddedBetween(
         request->arg1(), request->arg2(), &changes)) {
       if (!changes.empty()) {
         request->SetResult(
             new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes));
 
         // Post the notifications including the list of affected keys.
         // This is sent here so that work resulting from this notification
         // will be done on the DB thread, and not the UI thread.
         content::NotificationService::current()->Notify(
             chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
             content::Source<WebDataService>(this),
             content::Details<AutofillChangeList>(&changes));
       }
       ScheduleCommit();
     }
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveExpiredFormElementsImpl(WebDataRequest* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     AutofillChangeList changes;
     if (db_->GetAutofillTable()->RemoveExpiredFormElements(&changes)) {
       if (!changes.empty()) {
         request->SetResult(
             new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes));
 
         // Post the notifications including the list of affected keys.
         // This is sent here so that work resulting from this notification
         // will be done on the DB thread, and not the UI thread.
         content::NotificationService::current()->Notify(
             chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
             content::Source<WebDataService>(this),
             content::Details<AutofillChangeList>(&changes));
       }
       ScheduleCommit();
     }
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveFormValueForElementNameImpl(
     GenericRequest2<string16, string16>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const string16& name = request->arg1();
     const string16& value = request->arg2();
 
     if (db_->GetAutofillTable()->RemoveFormElement(name, value)) {
       AutofillChangeList changes;
       changes.push_back(AutofillChange(AutofillChange::REMOVE,
                                        AutofillKey(name, value)));
       request->SetResult(
           new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes));
       ScheduleCommit();
 
       // Post the notifications including the list of affected keys.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
           content::Source<WebDataService>(this),
           content::Details<AutofillChangeList>(&changes));
     }
   }
   request->RequestComplete();
 }
 
 void WebDataService::AddAutofillProfileImpl(
     GenericRequest<AutofillProfile>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const AutofillProfile& profile = request->arg();
     if (!db_->GetAutofillTable()->AddAutofillProfile(profile)) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
 
     // Send GUID-based notification.
     AutofillProfileChange change(AutofillProfileChange::ADD,
                                  profile.guid(), &profile);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillProfileChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::UpdateAutofillProfileImpl(
     GenericRequest<AutofillProfile>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const AutofillProfile& profile = request->arg();
 
     // Only perform the update if the profile exists.  It is currently
     // valid to try to update a missing profile.  We simply drop the write and
     // the caller will detect this on the next refresh.
     AutofillProfile* original_profile = NULL;
     if (!db_->GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                      &original_profile)) {
       request->RequestComplete();
       return;
@@ skipping 13 matching lines @@
         chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillProfileChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveAutofillProfileImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const std::string& guid = request->arg();
 
     AutofillProfile* profile = NULL;
     if (!db_->GetAutofillTable()->GetAutofillProfile(guid, &profile)) {
       NOTREACHED();
       return;
     }
     scoped_ptr<AutofillProfile> scoped_profile(profile);
 
     if (!db_->GetAutofillTable()->RemoveAutofillProfile(guid)) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
 
     // Send GUID-based notification.
     AutofillProfileChange change(AutofillProfileChange::REMOVE, guid, NULL);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillProfileChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetAutofillProfilesImpl(WebDataRequest* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<AutofillProfile*> profiles;
     db_->GetAutofillTable()->GetAutofillProfiles(&profiles);
     request->SetResult(
         new WDResult<std::vector<AutofillProfile*> >(AUTOFILL_PROFILES_RESULT,
-                                                     profiles));
+            base::Bind(&WebDataService::DestroyAutofillProfileResult,
+                base::Unretained(this)), profiles));
   }
   request->RequestComplete();
 }
 
 void WebDataService::EmptyMigrationTrashImpl(
     GenericRequest<bool>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     bool notify_sync = request->arg();
     if (notify_sync) {
       std::vector<std::string> guids;
       if (!db_->GetAutofillTable()->GetAutofillProfilesInTrash(&guids)) {
         NOTREACHED();
         return;
       }
 
       for (std::vector<std::string>::const_iterator iter = guids.begin();
            iter != guids.end(); ++iter) {
@@ skipping 30 matching lines @@
       return;
     }
     ScheduleCommit();
   }
   request->RequestComplete();
 }
 
 void WebDataService::AddCreditCardImpl(
     GenericRequest<CreditCard>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const CreditCard& credit_card = request->arg();
     if (!db_->GetAutofillTable()->AddCreditCard(credit_card)) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
 
     // Send GUID-based notification.
     AutofillCreditCardChange change(AutofillCreditCardChange::ADD,
                                     credit_card.guid(), &credit_card);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillCreditCardChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::UpdateCreditCardImpl(
     GenericRequest<CreditCard>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const CreditCard& credit_card = request->arg();
 
     // It is currently valid to try to update a missing profile.  We simply drop
     // the write and the caller will detect this on the next refresh.
     CreditCard* original_credit_card = NULL;
     if (!db_->GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                 &original_credit_card)) {
       request->RequestComplete();
       return;
     }
@@ skipping 12 matching lines @@
         chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillCreditCardChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveCreditCardImpl(
     GenericRequest<std::string>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     const std::string& guid = request->arg();
     if (!db_->GetAutofillTable()->RemoveCreditCard(guid)) {
       NOTREACHED();
       return;
     }
     ScheduleCommit();
 
     // Send GUID-based notification.
     AutofillCreditCardChange change(AutofillCreditCardChange::REMOVE, guid,
                                     NULL);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
         content::Source<WebDataService>(this),
         content::Details<AutofillCreditCardChange>(&change));
   }
   request->RequestComplete();
 }
 
 void WebDataService::GetCreditCardsImpl(WebDataRequest* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<CreditCard*> credit_cards;
     db_->GetAutofillTable()->GetCreditCards(&credit_cards);
     request->SetResult(
         new WDResult<std::vector<CreditCard*> >(AUTOFILL_CREDITCARDS_RESULT,
-                                                credit_cards));
+             base::Bind(&WebDataService::DestroyAutofillCreditCardResult,
+                base::Unretained(this)), credit_cards));
   }
   request->RequestComplete();
 }
 
 void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl(
     GenericRequest2<Time, Time>* request) {
   InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled(NULL)) {
+  if (db_ && !request->IsCancelled()) {
     std::vector<std::string> profile_guids;
     std::vector<std::string> credit_card_guids;
     if (db_->GetAutofillTable()->
         RemoveAutofillProfilesAndCreditCardsModifiedBetween(
             request->arg1(),
             request->arg2(),
             &profile_guids,
             &credit_card_guids)) {
       for (std::vector<std::string>::iterator iter = profile_guids.begin();
            iter != profile_guids.end(); ++iter) {
@@ skipping 31 matching lines @@
 }
 
 AutocompleteSyncableService* WebDataService::GetAutocompleteSyncableService()
     const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(autocomplete_syncable_service_);  // Make sure we're initialized.
 
   return autocomplete_syncable_service_;
 }
 
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// WebDataRequest implementation.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-WebDataService::WebDataRequest::WebDataRequest(WebDataService* service,
-                                               Handle handle,
-                                               WebDataServiceConsumer* consumer)
-    : service_(service),
-      handle_(handle),
-      cancelled_(false),
-      consumer_(consumer),
-      result_(NULL) {
-  message_loop_ = MessageLoop::current();
+void WebDataService::DestroyAutofillProfileResult(const WDTypedResult* result) {
+  DCHECK(result->GetType() == AUTOFILL_PROFILES_RESULT);
+  const WDResult<std::vector<AutofillProfile*> >* r =
+      static_cast<const WDResult<std::vector<AutofillProfile*> >*>(result);
+  std::vector<AutofillProfile*> profiles = r->GetValue();
+  STLDeleteElements(&profiles);
 }
 
-WebDataService::WebDataRequest::~WebDataRequest() {
-  delete result_;
+void WebDataService::DestroyAutofillCreditCardResult(
+      const WDTypedResult* result) {
+  DCHECK(result->GetType() == AUTOFILL_CREDITCARDS_RESULT);
+  const WDResult<std::vector<CreditCard*> >* r =
+      static_cast<const WDResult<std::vector<CreditCard*> >*>(result);
+
+  std::vector<CreditCard*> credit_cards = r->GetValue();
+  STLDeleteElements(&credit_cards);
 }
-
-WebDataService::Handle WebDataService::WebDataRequest::GetHandle() const {
-  return handle_;
-}
-
-bool WebDataService::WebDataRequest::IsCancelled(
-    WebDataServiceConsumer** consumer) const {
-  base::AutoLock l(cancel_lock_);
-  if (consumer)
-    *consumer = consumer_;
-  return cancelled_;
-}
-
-void WebDataService::WebDataRequest::Cancel() {
-  base::AutoLock l(cancel_lock_);
-  cancelled_ = true;
-  consumer_ = NULL;
-}
-
-void WebDataService::WebDataRequest::SetResult(WDTypedResult* r) {
-  result_ = r;
-}
-
-const WDTypedResult* WebDataService::WebDataRequest::GetResult() const {
-  return result_;
-}
-
-void WebDataService::WebDataRequest::RequestComplete() {
-  message_loop_->PostTask(FROM_HERE, Bind(&WebDataService::RequestCompleted,
-                                          service_.get(), handle_));
-}