Remove GenericRequest templates 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 132 matching lines @@
   return db_;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Keywords.
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddKeyword(const TemplateURLData& data) {
-  GenericRequest<TemplateURLData>* request =
-      new GenericRequest<TemplateURLData>(
-          this, NULL, &request_manager_, data);
-  ScheduleTask(FROM_HERE, Bind(&WebDataService::AddKeywordImpl, this, request));
+  ScheduleDBTask(
+      FROM_HERE, Bind(&WebDataService::AddKeywordImpl, this, data));
 }
 
 void WebDataService::RemoveKeyword(TemplateURLID id) {
-  GenericRequest<TemplateURLID>* request =
-      new GenericRequest<TemplateURLID>(this, NULL, &request_manager_, id);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveKeywordImpl, this, request));
+  ScheduleDBTask(
+      FROM_HERE, Bind(&WebDataService::RemoveKeywordImpl, this, id));
 }
 
 void WebDataService::UpdateKeyword(const TemplateURLData& data) {
-  GenericRequest<TemplateURLData>* request =
-      new GenericRequest<TemplateURLData>(
-          this, NULL, &request_manager_, data);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::UpdateKeywordImpl, this, request));
+  ScheduleDBTask(
+      FROM_HERE, Bind(&WebDataService::UpdateKeywordImpl, this, data));
 }
 
 WebDataService::Handle WebDataService::GetKeywords(
-                                       WebDataServiceConsumer* consumer) {
-  WebDataRequest* request =
-      new WebDataRequest(this, consumer, &request_manager_);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetKeywordsImpl, this, request));
-  return request->GetHandle();
+    WebDataServiceConsumer* consumer) {
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetKeywordsImpl, this), consumer);
 }
 
 void WebDataService::SetDefaultSearchProvider(const TemplateURL* url) {
-  GenericRequest<TemplateURLID>* request = new GenericRequest<TemplateURLID>(
-      this, NULL, &request_manager_, url ? url->id() : 0);
-  ScheduleTask(FROM_HERE, Bind(&WebDataService::SetDefaultSearchProviderImpl,
-                               this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::SetDefaultSearchProviderImpl, this,
+           url ? url->id() : 0));
 }
 
 void WebDataService::SetBuiltinKeywordVersion(int version) {
-  GenericRequest<int>* request = new GenericRequest<int>(
-      this, NULL, &request_manager_, version);
-  ScheduleTask(FROM_HERE, Bind(&WebDataService::SetBuiltinKeywordVersionImpl,
-                               this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::SetBuiltinKeywordVersionImpl, this, version));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Web Apps
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::SetWebAppImage(const GURL& app_url,
                                     const SkBitmap& image) {
-  GenericRequest2<GURL, SkBitmap>* request =
-      new GenericRequest2<GURL, SkBitmap>(
-          this, NULL, &request_manager_, app_url, image);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::SetWebAppImageImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::SetWebAppImageImpl, this, app_url, image));
 }
 
 void WebDataService::SetWebAppHasAllImages(const GURL& app_url,
                                            bool has_all_images) {
-  GenericRequest2<GURL, bool>* request =
-      new GenericRequest2<GURL, bool>(
-          this, NULL, &request_manager_, app_url, has_all_images);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::SetWebAppHasAllImagesImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::SetWebAppHasAllImagesImpl, this, app_url,
+           has_all_images));
 }
 
 void WebDataService::RemoveWebApp(const GURL& app_url) {
-  GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(this, NULL, &request_manager_, app_url);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveWebAppImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveWebAppImpl, this, app_url));
 }
 
 WebDataService::Handle WebDataService::GetWebAppImages(
     const GURL& app_url,
     WebDataServiceConsumer* consumer) {
-  GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(this, consumer, &request_manager_, app_url);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetWebAppImagesImpl, this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetWebAppImagesImpl, this, app_url), consumer);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Web Intents.
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddWebIntentService(const WebIntentServiceData& service) {
-  GenericRequest<WebIntentServiceData>* request =
-      new GenericRequest<WebIntentServiceData>(
-          this, NULL, &request_manager_, service);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::AddWebIntentServiceImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::AddWebIntentServiceImpl, this, service));
 }
 
 void WebDataService::RemoveWebIntentService(
     const WebIntentServiceData& service) {
-  GenericRequest<WebIntentServiceData>* request =
-      new GenericRequest<WebIntentServiceData>(
-          this, NULL, &request_manager_, service);
-  ScheduleTask(FROM_HERE, Bind(&WebDataService::RemoveWebIntentServiceImpl,
-                               this, request));
+  ScheduleDBTask(FROM_HERE, Bind(&WebDataService::RemoveWebIntentServiceImpl,
+                                 this, service));
 }
 
 WebDataService::Handle WebDataService::GetWebIntentServicesForAction(
     const string16& action,
     WebDataServiceConsumer* consumer) {
-  DCHECK(consumer);
-  GenericRequest<string16>* request =
-      new GenericRequest<string16>(
-          this, consumer, &request_manager_, action);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetWebIntentServicesImpl, this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetWebIntentServicesImpl, this, action), consumer);
 }
 
 WebDataService::Handle WebDataService::GetWebIntentServicesForURL(
     const string16& service_url,
     WebDataServiceConsumer* consumer) {
-  DCHECK(consumer);
-  GenericRequest<string16>* request =
-      new GenericRequest<string16>(
-          this, consumer, &request_manager_, service_url);
-  ScheduleTask(FROM_HERE, Bind(&WebDataService::GetWebIntentServicesForURLImpl,
-                               this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetWebIntentServicesForURLImpl, this, service_url),
+      consumer);
 }
 
 
 WebDataService::Handle WebDataService::GetAllWebIntentServices(
     WebDataServiceConsumer* consumer) {
-  DCHECK(consumer);
-  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();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetAllWebIntentServicesImpl, this), consumer);
 }
 
 void WebDataService::AddDefaultWebIntentService(
     const DefaultWebIntentService& service) {
-  GenericRequest<DefaultWebIntentService>* request =
-      new GenericRequest<DefaultWebIntentService>(
-          this, NULL, &request_manager_, service);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::AddDefaultWebIntentServiceImpl, this,
-                    request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::AddDefaultWebIntentServiceImpl, this, service));
 }
 
 void WebDataService::RemoveDefaultWebIntentService(
     const DefaultWebIntentService& service) {
-  GenericRequest<DefaultWebIntentService>* request =
-      new GenericRequest<DefaultWebIntentService>(
-          this, NULL, &request_manager_, service);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveDefaultWebIntentServiceImpl, this,
-                    request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveDefaultWebIntentServiceImpl, this, service));
 }
 
 void WebDataService::RemoveWebIntentServiceDefaults(
     const GURL& service_url) {
-  GenericRequest<GURL>* request =
-      new GenericRequest<GURL>(this, NULL, &request_manager_, service_url);
-  ScheduleTask(
-      FROM_HERE,
-      Bind(&WebDataService::RemoveWebIntentServiceDefaultsImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveWebIntentServiceDefaultsImpl, this,
+           service_url));
 }
 
 WebDataService::Handle WebDataService::GetDefaultWebIntentServicesForAction(
     const string16& action,
     WebDataServiceConsumer* consumer) {
-  DCHECK(consumer);
-  GenericRequest<string16>* request = new GenericRequest<string16>(
-      this, consumer, &request_manager_, action);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetDefaultWebIntentServicesForActionImpl,
-                    this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetDefaultWebIntentServicesForActionImpl, this,
+           action),
+      consumer);
 }
 
 WebDataService::Handle WebDataService::GetAllDefaultWebIntentServices(
     WebDataServiceConsumer* consumer) {
-  DCHECK(consumer);
-  GenericRequest<std::string>* request = new GenericRequest<std::string>(
-      this, consumer, &request_manager_, std::string());
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetAllDefaultWebIntentServicesImpl,
-                    this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetAllDefaultWebIntentServicesImpl, this),
+      consumer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // 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, NULL, &request_manager_, service, token);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::SetTokenForServiceImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::SetTokenForServiceImpl, this, service, token));
 }
 
 void WebDataService::RemoveAllTokens() {
-  GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(
-          this, NULL, &request_manager_, std::string());
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveAllTokensImpl, this, request));
+  ScheduleDBTask(FROM_HERE, Bind(&WebDataService::RemoveAllTokensImpl, this));
 }
 
 // Null on failure. Success is WDResult<std::string>
 WebDataService::Handle WebDataService::GetAllTokens(
     WebDataServiceConsumer* consumer) {
-
-  GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(
-          this, consumer, &request_manager_, std::string());
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetAllTokensImpl, this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetAllTokensImpl, this), consumer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Autofill.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddFormFields(
     const std::vector<FormFieldData>& fields) {
-  GenericRequest<std::vector<FormFieldData> >* request =
-      new GenericRequest<std::vector<FormFieldData> >(
-          this, NULL, &request_manager_, fields);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::AddFormElementsImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::AddFormElementsImpl, this, fields));
 }
 
 WebDataService::Handle WebDataService::GetFormValuesForElementName(
     const string16& name, const string16& prefix, int limit,
     WebDataServiceConsumer* consumer) {
-  WebDataRequest* request =
-      new WebDataRequest(this, consumer, &request_manager_);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetFormValuesForElementNameImpl,
-                    this, request, name, prefix, limit));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetFormValuesForElementNameImpl,
+           this, name, prefix, limit),
+      consumer);
 }
 
 void WebDataService::RemoveFormElementsAddedBetween(const Time& delete_begin,
                                                     const Time& delete_end) {
-  GenericRequest2<Time, Time>* request =
-    new GenericRequest2<Time, Time>(
-        this, NULL, &request_manager_, delete_begin, delete_end);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveFormElementsAddedBetweenImpl,
-                    this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveFormElementsAddedBetweenImpl,
+           this, delete_begin, delete_end));
 }
 
 void WebDataService::RemoveExpiredFormElements() {
-  WebDataRequest* request =
-      new WebDataRequest(this, NULL, &request_manager_);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveExpiredFormElementsImpl,
-                    this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveExpiredFormElementsImpl, this));
 }
 
 void WebDataService::RemoveFormValueForElementName(
     const string16& name, const string16& value) {
-  GenericRequest2<string16, string16>* request =
-      new GenericRequest2<string16, string16>(
-          this, NULL, &request_manager_, name, value);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveFormValueForElementNameImpl,
-                    this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveFormValueForElementNameImpl,
+           this, name, value));
 }
 
 void WebDataService::AddAutofillProfile(const AutofillProfile& profile) {
-  GenericRequest<AutofillProfile>* request =
-      new GenericRequest<AutofillProfile>(
-          this, NULL, &request_manager_, profile);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::AddAutofillProfileImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::AddAutofillProfileImpl, this, profile));
 }
 
 void WebDataService::UpdateAutofillProfile(const AutofillProfile& profile) {
-  GenericRequest<AutofillProfile>* request =
-      new GenericRequest<AutofillProfile>(
-          this, NULL, &request_manager_, profile);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::UpdateAutofillProfileImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::UpdateAutofillProfileImpl, this, profile));
 }
 
 void WebDataService::RemoveAutofillProfile(const std::string& guid) {
-  GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(this, NULL, &request_manager_, guid);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveAutofillProfileImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveAutofillProfileImpl, this, guid));
 }
 
 WebDataService::Handle WebDataService::GetAutofillProfiles(
     WebDataServiceConsumer* consumer) {
-  WebDataRequest* request =
-    new WebDataRequest(this, consumer, &request_manager_);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetAutofillProfilesImpl, this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetAutofillProfilesImpl, this), consumer);
 }
 
 void WebDataService::EmptyMigrationTrash(bool notify_sync) {
-  GenericRequest<bool>* request =
-      new GenericRequest<bool>(this, NULL, &request_manager_, notify_sync);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::EmptyMigrationTrashImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::EmptyMigrationTrashImpl, this, notify_sync));
 }
 
 void WebDataService::AddCreditCard(const CreditCard& credit_card) {
-  GenericRequest<CreditCard>* request =
-      new GenericRequest<CreditCard>(
-          this, NULL, &request_manager_, credit_card);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::AddCreditCardImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::AddCreditCardImpl, this, credit_card));
 }
 
 void WebDataService::UpdateCreditCard(const CreditCard& credit_card) {
-  GenericRequest<CreditCard>* request =
-      new GenericRequest<CreditCard>(
-          this, NULL, &request_manager_, credit_card);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::UpdateCreditCardImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::UpdateCreditCardImpl, this, credit_card));
 }
 
 void WebDataService::RemoveCreditCard(const std::string& guid) {
-  GenericRequest<std::string>* request =
-      new GenericRequest<std::string>(this, NULL, &request_manager_, guid);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::RemoveCreditCardImpl, this, request));
+  ScheduleDBTask(FROM_HERE,
+      Bind(&WebDataService::RemoveCreditCardImpl, this, guid));
 }
 
 WebDataService::Handle WebDataService::GetCreditCards(
     WebDataServiceConsumer* consumer) {
-  WebDataRequest* request =
-      new WebDataRequest(this, consumer, &request_manager_);
-  ScheduleTask(FROM_HERE,
-               Bind(&WebDataService::GetCreditCardsImpl, this, request));
-  return request->GetHandle();
+  return ScheduleDBTaskWithResult(FROM_HERE,
+      Bind(&WebDataService::GetCreditCardsImpl, this), consumer);
 }
 
 void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end) {
-  GenericRequest2<Time, Time>* request =
-      new GenericRequest2<Time, Time>(
-          this, NULL, &request_manager_, delete_begin, delete_end);
-  ScheduleTask(FROM_HERE, Bind(
+  ScheduleDBTask(FROM_HERE, Bind(
       &WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl,
-      this, request));
+      this, delete_begin, delete_end));
 }
 
 WebDataService::~WebDataService() {
   if (is_running_ && db_) {
     DLOG_ASSERT("WebDataService dtor called without Shutdown");
     NOTREACHED();
   }
 }
 
 bool WebDataService::InitWithPath(const FilePath& path) {
@@ skipping 101 matching lines @@
 }
 
 void WebDataService::ScheduleTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task) {
   if (is_running_)
     BrowserThread::PostTask(BrowserThread::DB, from_here, task);
   else
     NOTREACHED() << "Task scheduled after Shutdown()";
 }
 
+void WebDataService::ScheduleDBTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task) {
+  WebDataRequest* request =
+      new WebDataRequest(this, NULL, &request_manager_);
+  if (is_running_) {
+    BrowserThread::PostTask(BrowserThread::DB, from_here,
+        base::Bind(&WebDataService::DBTaskWrapper, this, task, request));
+  } else {
+    NOTREACHED() << "Task scheduled after Shutdown()";
+  }
+}
+
+WebDataService::Handle WebDataService::ScheduleDBTaskWithResult(
+      const tracked_objects::Location& from_here,
+      const ResultTask& task,
+      WebDataServiceConsumer* consumer) {
+  DCHECK(consumer);
+  WebDataRequest* request =
+      new WebDataRequest(this, consumer, &request_manager_);
+  if (is_running_) {
+    BrowserThread::PostTask(BrowserThread::DB, from_here,
+        base::Bind(&WebDataService::DBResultTaskWrapper, this, task, request));
+  } else {
+    NOTREACHED() << "Task scheduled after Shutdown()";
+  }
+  return request->GetHandle();
+}
+
+void WebDataService::DBTaskWrapper(const base::Closure& task,
+                                   WebDataRequest* request) {
+  InitializeDatabaseIfNecessary();
+  if (db_ && !request->IsCancelled()) {
+    task.Run();
+  }
+  request->RequestComplete();
+}
+
+void WebDataService::DBResultTaskWrapper(const ResultTask& task,
+                                         WebDataRequest* request) {
+  InitializeDatabaseIfNecessary();
+  if (db_ && !request->IsCancelled()) {
+    request->SetResult(task.Run().Pass());
+  }
+  request->RequestComplete();
+}
+
 void WebDataService::ScheduleCommit() {
   if (should_commit_ == false) {
     should_commit_ = true;
     ScheduleTask(FROM_HERE, Bind(&WebDataService::Commit, this));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Keywords implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-void WebDataService::AddKeywordImpl(GenericRequest<TemplateURLData>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    db_->GetKeywordTable()->AddKeyword(request->arg());
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+void WebDataService::AddKeywordImpl(const TemplateURLData& data) {
+  db_->GetKeywordTable()->AddKeyword(data);
+  ScheduleCommit();
 }
 
-void WebDataService::RemoveKeywordImpl(GenericRequest<TemplateURLID>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    DCHECK(request->arg());
-    db_->GetKeywordTable()->RemoveKeyword(request->arg());
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+void WebDataService::RemoveKeywordImpl(TemplateURLID id) {
+  DCHECK(id);
+  db_->GetKeywordTable()->RemoveKeyword(id);
+  ScheduleCommit();
 }
 
-void WebDataService::UpdateKeywordImpl(
-    GenericRequest<TemplateURLData>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    if (!db_->GetKeywordTable()->UpdateKeyword(request->arg())) {
-      NOTREACHED();
-      return;
-    }
-    ScheduleCommit();
+void WebDataService::UpdateKeywordImpl(const TemplateURLData& data) {
+  if (!db_->GetKeywordTable()->UpdateKeyword(data)) {
+    NOTREACHED();
+    return;
   }
-  request->RequestComplete();
+  ScheduleCommit();
 }
 
-void WebDataService::GetKeywordsImpl(WebDataRequest* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetKeywordsImpl() {
+  WDKeywordsResult result;
+  db_->GetKeywordTable()->GetKeywords(&result.keywords);
+  result.default_search_provider_id =
+      db_->GetKeywordTable()->GetDefaultSearchProviderID();
+  result.builtin_keyword_version =
+      db_->GetKeywordTable()->GetBuiltinKeywordVersion();
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<WDKeywordsResult>(KEYWORDS_RESULT, result));
 }
 
-void WebDataService::SetDefaultSearchProviderImpl(
-    GenericRequest<TemplateURLID>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    if (!db_->GetKeywordTable()->SetDefaultSearchProviderID(request->arg())) {
-      NOTREACHED();
-      return;
-    }
-    ScheduleCommit();
+void WebDataService::SetDefaultSearchProviderImpl(TemplateURLID id) {
+  if (!db_->GetKeywordTable()->SetDefaultSearchProviderID(id)) {
+    NOTREACHED();
+    return;
   }
-  request->RequestComplete();
+  ScheduleCommit();
 }
 
-void WebDataService::SetBuiltinKeywordVersionImpl(
-    GenericRequest<int>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    if (!db_->GetKeywordTable()->SetBuiltinKeywordVersion(request->arg())) {
-      NOTREACHED();
-      return;
-    }
-    ScheduleCommit();
+void WebDataService::SetBuiltinKeywordVersionImpl(int version) {
+  if (!db_->GetKeywordTable()->SetBuiltinKeywordVersion(version)) {
+    NOTREACHED();
+    return;
   }
-  request->RequestComplete();
+  ScheduleCommit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Web Apps implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::SetWebAppImageImpl(
-    GenericRequest2<GURL, SkBitmap>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    db_->GetWebAppsTable()->SetWebAppImage(
-        request->arg1(), request->arg2());
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const GURL& app_url, const SkBitmap& image) {
+  db_->GetWebAppsTable()->SetWebAppImage(app_url, image);
+  ScheduleCommit();
 }
 
 void WebDataService::SetWebAppHasAllImagesImpl(
-    GenericRequest2<GURL, bool>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    db_->GetWebAppsTable()->SetWebAppHasAllImages(request->arg1(),
-                                                  request->arg2());
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const GURL& app_url, bool has_all_images) {
+  db_->GetWebAppsTable()->SetWebAppHasAllImages(app_url, has_all_images);
+  ScheduleCommit();
 }
 
-void WebDataService::RemoveWebAppImpl(GenericRequest<GURL>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    db_->GetWebAppsTable()->RemoveWebApp(request->arg());
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+void WebDataService::RemoveWebAppImpl(const GURL& app_url) {
+  db_->GetWebAppsTable()->RemoveWebApp(app_url);
+  ScheduleCommit();
 }
 
-void WebDataService::GetWebAppImagesImpl(GenericRequest<GURL>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetWebAppImagesImpl(
+    const GURL& app_url) {
+  WDAppImagesResult result;
+  result.has_all_images =
+      db_->GetWebAppsTable()->GetWebAppHasAllImages(app_url);
+  db_->GetWebAppsTable()->GetWebAppImages(app_url, &result.images);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<WDAppImagesResult>(WEB_APP_IMAGES, result));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Web Intents implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::RemoveWebIntentServiceImpl(
-    GenericRequest<WebIntentServiceData>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    const WebIntentServiceData& service = request->arg();
-    db_->GetWebIntentsTable()->RemoveWebIntentService(service);
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const webkit_glue::WebIntentServiceData& service) {
+  db_->GetWebIntentsTable()->RemoveWebIntentService(service);
+  ScheduleCommit();
 }
 
 void WebDataService::AddWebIntentServiceImpl(
-    GenericRequest<WebIntentServiceData>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    const WebIntentServiceData& service = request->arg();
-    db_->GetWebIntentsTable()->SetWebIntentService(service);
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const webkit_glue::WebIntentServiceData& service) {
+  db_->GetWebIntentsTable()->SetWebIntentService(service);
+  ScheduleCommit();
 }
 
 
-void WebDataService::GetWebIntentServicesImpl(
-    GenericRequest<string16>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetWebIntentServicesImpl(
+    const string16& action) {
+  std::vector<WebIntentServiceData> result;
+  db_->GetWebIntentsTable()->GetWebIntentServicesForAction(action, &result);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<WebIntentServiceData> >(
+          WEB_INTENTS_RESULT, result));
 }
 
-void WebDataService::GetWebIntentServicesForURLImpl(
-    GenericRequest<string16>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetWebIntentServicesForURLImpl(
+    const string16& service_url) {
+  std::vector<WebIntentServiceData> result;
+  db_->GetWebIntentsTable()->GetWebIntentServicesForURL(service_url, &result);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<WebIntentServiceData> >(
+          WEB_INTENTS_RESULT, result));
 }
 
-void WebDataService::GetAllWebIntentServicesImpl(
-    GenericRequest<std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetAllWebIntentServicesImpl() {
+  std::vector<WebIntentServiceData> result;
+  db_->GetWebIntentsTable()->GetAllWebIntentServices(&result);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<WebIntentServiceData> >(
+          WEB_INTENTS_RESULT, result));
 }
 
 void WebDataService::AddDefaultWebIntentServiceImpl(
-    GenericRequest<DefaultWebIntentService>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    const DefaultWebIntentService& service = request->arg();
-    db_->GetWebIntentsTable()->SetDefaultService(service);
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const DefaultWebIntentService& service) {
+  db_->GetWebIntentsTable()->SetDefaultService(service);
+  ScheduleCommit();
 }
 
 void WebDataService::RemoveDefaultWebIntentServiceImpl(
-    GenericRequest<DefaultWebIntentService>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    const DefaultWebIntentService& service = request->arg();
-    db_->GetWebIntentsTable()->RemoveDefaultService(service);
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const DefaultWebIntentService& service) {
+  db_->GetWebIntentsTable()->RemoveDefaultService(service);
+  ScheduleCommit();
 }
 
 void WebDataService::RemoveWebIntentServiceDefaultsImpl(
-    GenericRequest<GURL>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    const GURL& service_url = request->arg();
-    db_->GetWebIntentsTable()->RemoveServiceDefaults(service_url);
-    ScheduleCommit();
-  }
-  request->RequestComplete();
+    const GURL& service_url) {
+  db_->GetWebIntentsTable()->RemoveServiceDefaults(service_url);
+  ScheduleCommit();
 }
 
-void WebDataService::GetDefaultWebIntentServicesForActionImpl(
-    GenericRequest<string16>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult>
+    WebDataService::GetDefaultWebIntentServicesForActionImpl(
+    const string16& action) {
+  std::vector<DefaultWebIntentService> result;
+  db_->GetWebIntentsTable()->GetDefaultServices(action, &result);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<DefaultWebIntentService> >(
+          WEB_INTENTS_DEFAULTS_RESULT, result));
 }
 
-void WebDataService::GetAllDefaultWebIntentServicesImpl(
-    GenericRequest<std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetAllDefaultWebIntentServicesImpl() {
+  std::vector<DefaultWebIntentService> result;
+  db_->GetWebIntentsTable()->GetAllDefaultServices(&result);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<DefaultWebIntentService> >(
+          WEB_INTENTS_DEFAULTS_RESULT, result));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Token Service implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-// argument std::string is unused
-void WebDataService::RemoveAllTokensImpl(
-    GenericRequest<std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    if (db_->GetTokenServiceTable()->RemoveAllTokens()) {
-      ScheduleCommit();
-    }
+void WebDataService::RemoveAllTokensImpl() {
+  if (db_->GetTokenServiceTable()->RemoveAllTokens()) {
+    ScheduleCommit();
   }
-  request->RequestComplete();
 }
 
-void WebDataService::SetTokenForServiceImpl(
-    GenericRequest2<std::string, std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
-    if (db_->GetTokenServiceTable()->SetTokenForService(
-            request->arg1(), request->arg2())) {
-      ScheduleCommit();
-    }
+void WebDataService::SetTokenForServiceImpl(const std::string& service,
+                                            const std::string& token) {
+  if (db_->GetTokenServiceTable()->SetTokenForService(service, token)) {
+    ScheduleCommit();
   }
-  request->RequestComplete();
 }
 
-// argument is unused
-void WebDataService::GetAllTokensImpl(
-    GenericRequest<std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  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();
+scoped_ptr<WDTypedResult> WebDataService::GetAllTokensImpl() {
+  std::map<std::string, std::string> map;
+  db_->GetTokenServiceTable()->GetAllTokens(&map);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::map<std::string, std::string> >(TOKEN_RESULT, map));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Autofill implementation.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddFormElementsImpl(
-    GenericRequest<std::vector<FormFieldData> >* request) {
-  InitializeDatabaseIfNecessary();
-  if (db_ && !request->IsCancelled()) {
+    const std::vector<FormFieldData>& fields) {
+  AutofillChangeList changes;
+  if (!db_->GetAutofillTable()->AddFormFieldValues(fields, &changes)) {
+    NOTREACHED();
+    return;
+  }
+  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));
+}
+
+scoped_ptr<WDTypedResult> WebDataService::GetFormValuesForElementNameImpl(
+  const string16& name, const string16& prefix, int limit) {
+  std::vector<string16> values;
+  db_->GetAutofillTable()->GetFormValuesForElementName(
+      name, prefix, &values, limit);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<string16> >(AUTOFILL_VALUE_RESULT, values));
+}
+
+void WebDataService::RemoveFormElementsAddedBetweenImpl(
+  const base::Time& delete_begin, const base::Time& delete_end) {
+  AutofillChangeList changes;
+  if (db_->GetAutofillTable()->RemoveFormElementsAddedBetween(
+      delete_begin, delete_end, &changes)) {
+    if (!changes.empty()) {
+      // 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();
+  }
+}
+
+void WebDataService::RemoveExpiredFormElementsImpl() {
+  AutofillChangeList changes;
+
+  if (db_->GetAutofillTable()->RemoveExpiredFormElements(&changes)) {
+    if (!changes.empty()) {
+      // 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();
+  }
+}
+
+void WebDataService::RemoveFormValueForElementNameImpl(
+    const string16& name, const string16& value) {
+
+  if (db_->GetAutofillTable()->RemoveFormElement(name, value)) {
     AutofillChangeList changes;
-    if (!db_->GetAutofillTable()->AddFormFieldValues(
-            request->arg(), &changes)) {
-      NOTREACHED();
-      return;
-    }
-    request->SetResult(
-        new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes));
+    changes.push_back(AutofillChange(AutofillChange::REMOVE,
+                                     AutofillKey(name, value)));
     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()) {
-    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()) {
-    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()) {
-    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()) {
-    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()) {
-    const AutofillProfile& profile = request->arg();
-    if (!db_->GetAutofillTable()->AddAutofillProfile(profile)) {
+}
+
+void WebDataService::AddAutofillProfileImpl(const AutofillProfile& profile) {
+  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));
+}
+
+void WebDataService::UpdateAutofillProfileImpl(const AutofillProfile& profile) {
+  // 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)) {
+    return;
+  }
+  scoped_ptr<AutofillProfile> scoped_profile(original_profile);
+
+  if (!db_->GetAutofillTable()->UpdateAutofillProfileMulti(profile)) {
+    NOTREACHED();
+    return;
+  }
+  ScheduleCommit();
+
+  // Send GUID-based notification.
+  AutofillProfileChange change(AutofillProfileChange::UPDATE,
+                               profile.guid(), &profile);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
+      content::Source<WebDataService>(this),
+      content::Details<AutofillProfileChange>(&change));
+}
+
+void WebDataService::RemoveAutofillProfileImpl(const std::string& guid) {
+  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));
+}
+
+scoped_ptr<WDTypedResult> WebDataService::GetAutofillProfilesImpl() {
+  std::vector<AutofillProfile*> profiles;
+  db_->GetAutofillTable()->GetAutofillProfiles(&profiles);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<AutofillProfile*> >(
+          AUTOFILL_PROFILES_RESULT,
+          base::Bind(&WebDataService::DestroyAutofillProfileResult,
+              base::Unretained(this)),
+          profiles));
+}
+
+void WebDataService::EmptyMigrationTrashImpl(bool notify_sync) {
+  if (notify_sync) {
+    std::vector<std::string> guids;
+    if (!db_->GetAutofillTable()->GetAutofillProfilesInTrash(&guids)) {
       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()) {
-    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;
-    }
-    scoped_ptr<AutofillProfile> scoped_profile(original_profile);
-
-    if (!db_->GetAutofillTable()->UpdateAutofillProfileMulti(profile)) {
-      NOTREACHED();
-      return;
-    }
-    ScheduleCommit();
-
-    // Send GUID-based notification.
-    AutofillProfileChange change(AutofillProfileChange::UPDATE,
-                                 profile.guid(), &profile);
-    content::NotificationService::current()->Notify(
-        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()) {
-    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()) {
-    std::vector<AutofillProfile*> profiles;
-    db_->GetAutofillTable()->GetAutofillProfiles(&profiles);
-    request->SetResult(
-        new WDResult<std::vector<AutofillProfile*> >(AUTOFILL_PROFILES_RESULT,
-            base::Bind(&WebDataService::DestroyAutofillProfileResult,
-                base::Unretained(this)), profiles));
-  }
-  request->RequestComplete();
-}
-
-void WebDataService::EmptyMigrationTrashImpl(
-    GenericRequest<bool>* request) {
-  InitializeDatabaseIfNecessary();
-  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) {
-        // Send GUID-based notification.
-        AutofillProfileChange change(AutofillProfileChange::REMOVE,
-                                     *iter, NULL);
+
+    for (std::vector<std::string>::const_iterator iter = guids.begin();
+         iter != guids.end(); ++iter) {
+      // Send GUID-based notification.
+      AutofillProfileChange change(AutofillProfileChange::REMOVE,
+                                   *iter, NULL);
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
+          content::Source<WebDataService>(this),
+          content::Details<AutofillProfileChange>(&change));
+    }
+
+    // If we trashed any profiles they may have been merged, so send out
+    // update notifications as well.
+    if (!guids.empty()) {
+      std::vector<AutofillProfile*> profiles;
+      db_->GetAutofillTable()->GetAutofillProfiles(&profiles);
+      for (std::vector<AutofillProfile*>::const_iterator
+              iter = profiles.begin();
+           iter != profiles.end(); ++iter) {
+        AutofillProfileChange change(AutofillProfileChange::UPDATE,
+                                     (*iter)->guid(), *iter);
         content::NotificationService::current()->Notify(
             chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
             content::Source<WebDataService>(this),
             content::Details<AutofillProfileChange>(&change));
       }
-
-      // If we trashed any profiles they may have been merged, so send out
-      // update notifications as well.
-      if (!guids.empty()) {
-        std::vector<AutofillProfile*> profiles;
-        db_->GetAutofillTable()->GetAutofillProfiles(&profiles);
-        for (std::vector<AutofillProfile*>::const_iterator
-                iter = profiles.begin();
-             iter != profiles.end(); ++iter) {
-          AutofillProfileChange change(AutofillProfileChange::UPDATE,
-                                       (*iter)->guid(), *iter);
-          content::NotificationService::current()->Notify(
-              chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
-              content::Source<WebDataService>(this),
-              content::Details<AutofillProfileChange>(&change));
-        }
-        STLDeleteElements(&profiles);
-      }
-    }
-
-    if (!db_->GetAutofillTable()->EmptyAutofillProfilesTrash()) {
-      NOTREACHED();
-      return;
-    }
+      STLDeleteElements(&profiles);
+    }
+  }
+
+  if (!db_->GetAutofillTable()->EmptyAutofillProfilesTrash()) {
+    NOTREACHED();
+    return;
+  }
+  ScheduleCommit();
+}
+
+void WebDataService::AddCreditCardImpl(const CreditCard& credit_card) {
+  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));
+}
+
+void WebDataService::UpdateCreditCardImpl(const CreditCard& credit_card) {
+  // 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)) {
+    return;
+  }
+  scoped_ptr<CreditCard> scoped_credit_card(original_credit_card);
+
+  if (!db_->GetAutofillTable()->UpdateCreditCard(credit_card)) {
+    NOTREACHED();
+    return;
+  }
+  ScheduleCommit();
+
+  // Send GUID-based notification.
+  AutofillCreditCardChange change(AutofillCreditCardChange::UPDATE,
+                                  credit_card.guid(), &credit_card);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
+      content::Source<WebDataService>(this),
+      content::Details<AutofillCreditCardChange>(&change));
+}
+
+void WebDataService::RemoveCreditCardImpl(const std::string& guid) {
+  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));
+}
+
+scoped_ptr<WDTypedResult> WebDataService::GetCreditCardsImpl() {
+  std::vector<CreditCard*> credit_cards;
+  db_->GetAutofillTable()->GetCreditCards(&credit_cards);
+  return scoped_ptr<WDTypedResult>(
+      new WDResult<std::vector<CreditCard*> >(
+          AUTOFILL_CREDITCARDS_RESULT,
+          base::Bind(&WebDataService::DestroyAutofillCreditCardResult,
+              base::Unretained(this)),
+          credit_cards));
+}
+
+void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl(
+  const base::Time& delete_begin, const base::Time& delete_end) {
+  std::vector<std::string> profile_guids;
+  std::vector<std::string> credit_card_guids;
+  if (db_->GetAutofillTable()->
+      RemoveAutofillProfilesAndCreditCardsModifiedBetween(
+          delete_begin,
+          delete_end,
+          &profile_guids,
+          &credit_card_guids)) {
+    for (std::vector<std::string>::iterator iter = profile_guids.begin();
+         iter != profile_guids.end(); ++iter) {
+      AutofillProfileChange change(AutofillProfileChange::REMOVE, *iter,
+                                   NULL);
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
+          content::Source<WebDataService>(this),
+          content::Details<AutofillProfileChange>(&change));
+    }
+
+    for (std::vector<std::string>::iterator iter = credit_card_guids.begin();
+         iter != credit_card_guids.end(); ++iter) {
+      AutofillCreditCardChange change(AutofillCreditCardChange::REMOVE,
+                                      *iter, NULL);
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
+          content::Source<WebDataService>(this),
+          content::Details<AutofillCreditCardChange>(&change));
+    }
+    // Note: It is the caller's responsibility to post notifications for any
+    // changes, e.g. by calling the Refresh() method of PersonalDataManager.
     ScheduleCommit();
   }
-  request->RequestComplete();
-}
-
-void WebDataService::AddCreditCardImpl(
-    GenericRequest<CreditCard>* request) {
-  InitializeDatabaseIfNecessary();
-  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()) {
-    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;
-    }
-    scoped_ptr<CreditCard> scoped_credit_card(original_credit_card);
-
-    if (!db_->GetAutofillTable()->UpdateCreditCard(credit_card)) {
-      NOTREACHED();
-      return;
-    }
-    ScheduleCommit();
-
-    // Send GUID-based notification.
-    AutofillCreditCardChange change(AutofillCreditCardChange::UPDATE,
-                                    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::RemoveCreditCardImpl(
-    GenericRequest<std::string>* request) {
-  InitializeDatabaseIfNecessary();
-  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()) {
-    std::vector<CreditCard*> credit_cards;
-    db_->GetAutofillTable()->GetCreditCards(&credit_cards);
-    request->SetResult(
-        new WDResult<std::vector<CreditCard*> >(AUTOFILL_CREDITCARDS_RESULT,
-             base::Bind(&WebDataService::DestroyAutofillCreditCardResult,
-                base::Unretained(this)), credit_cards));
-  }
-  request->RequestComplete();
-}
-
-void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl(
-    GenericRequest2<Time, Time>* request) {
-  InitializeDatabaseIfNecessary();
-  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) {
-        AutofillProfileChange change(AutofillProfileChange::REMOVE, *iter,
-                                     NULL);
-        content::NotificationService::current()->Notify(
-            chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
-            content::Source<WebDataService>(this),
-            content::Details<AutofillProfileChange>(&change));
-      }
-
-      for (std::vector<std::string>::iterator iter = credit_card_guids.begin();
-           iter != credit_card_guids.end(); ++iter) {
-        AutofillCreditCardChange change(AutofillCreditCardChange::REMOVE,
-                                        *iter, NULL);
-        content::NotificationService::current()->Notify(
-            chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
-            content::Source<WebDataService>(this),
-            content::Details<AutofillCreditCardChange>(&change));
-      }
-      // Note: It is the caller's responsibility to post notifications for any
-      // changes, e.g. by calling the Refresh() method of PersonalDataManager.
-      ScheduleCommit();
-    }
-  }
-  request->RequestComplete();
 }
 
 AutofillProfileSyncableService*
     WebDataService::GetAutofillProfileSyncableService() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(autofill_profile_syncable_service_);  // Make sure we're initialized.
 
   return autofill_profile_syncable_service_;
 }
 
@@ skipping 15 matching lines @@
 
 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);
 }