Disambiguate origins of tasks posted by the WebDataService.

chrome/browser/webdata/web_data_service.cc

 // Copyright (c) 2011 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 90 matching lines @@
            make_scoped_refptr(web_data_service)));
 }
 
 bool WebDataService::Init(const FilePath& profile_path) {
   FilePath path = profile_path;
   path = path.Append(chrome::kWebDataFilename);
   return InitWithPath(path);
 }
 
 void WebDataService::Shutdown() {
-  ScheduleTask(Bind(&WebDataService::ShutdownSyncableServices, this));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::ShutdownSyncableServices, this));
   UnloadDatabase();
 }
 
 bool WebDataService::IsRunning() const {
   return is_running_;
 }
 
 void WebDataService::UnloadDatabase() {
-  ScheduleTask(Bind(&WebDataService::ShutdownDatabase, this));
+  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();
@@ skipping 14 matching lines @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddKeyword(const TemplateURL& url) {
   // Ensure that the keyword is already generated (and cached) before caching
   // the TemplateURL for use on another keyword.
   url.EnsureKeyword();
   GenericRequest<TemplateURL>* request =
     new GenericRequest<TemplateURL>(this, GetNextRequestHandle(), NULL, url);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::AddKeywordImpl, this, request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::AddKeywordImpl, this, request));
 }
 
 void WebDataService::RemoveKeyword(const TemplateURL& url) {
   GenericRequest<TemplateURLID>* request =
       new GenericRequest<TemplateURLID>(this, GetNextRequestHandle(),
                                         NULL, url.id());
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::RemoveKeywordImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::RemoveKeywordImpl, this, request));
 }
 
 void WebDataService::UpdateKeyword(const TemplateURL& url) {
   // Ensure that the keyword is already generated (and cached) before caching
   // the TemplateURL for use on another keyword.
   url.EnsureKeyword();
   GenericRequest<TemplateURL>* request =
       new GenericRequest<TemplateURL>(this, GetNextRequestHandle(), NULL, url);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::UpdateKeywordImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::UpdateKeywordImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetKeywords(
                                        WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
       new WebDataRequest(this, GetNextRequestHandle(), consumer);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetKeywordsImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::SetDefaultSearchProviderImpl,
-                    this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::SetBuiltinKeywordVersionImpl,
-                    this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::SetWebAppImageImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::SetWebAppHasAllImagesImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveWebAppImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::GetWebAppImagesImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::AddWebIntentServiceImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveWebIntentServiceImpl,
-                    this,
-                    request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::RemoveWebIntentServiceImpl,
+                               this, request));
 }
 
 WebDataService::Handle WebDataService::GetWebIntentServices(
     const string16& action,
     WebDataServiceConsumer* consumer) {
   DCHECK(consumer);
   GenericRequest<string16>* request = new GenericRequest<string16>(
       this, GetNextRequestHandle(), consumer, action);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetWebIntentServicesImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::GetWebIntentServicesForURLImpl,
-                    this,
-                    request));
+  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);
-  ScheduleTask(Bind(&WebDataService::GetAllWebIntentServicesImpl,
-                    this,
-                    request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::GetAllWebIntentServicesImpl,
+                               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);
-  ScheduleTask(Bind(&WebDataService::SetTokenForServiceImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveAllTokensImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::GetAllTokensImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::GetAllTokensImpl, this, request));
   return request->GetHandle();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Password manager.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddLogin(const PasswordForm& form) {
   GenericRequest<PasswordForm>* request =
       new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), NULL,
                                        form);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::AddLoginImpl, this, request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::AddLoginImpl, this, request));
 }
 
 void WebDataService::UpdateLogin(const PasswordForm& form) {
   GenericRequest<PasswordForm>* request =
       new GenericRequest<PasswordForm>(this, GetNextRequestHandle(),
                                        NULL, form);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::UpdateLoginImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::UpdateLoginImpl, this, request));
 }
 
 void WebDataService::RemoveLogin(const PasswordForm& form) {
   GenericRequest<PasswordForm>* request =
      new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), NULL,
                                       form);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::RemoveLoginImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::RemoveLoginImpl, this, request));
 }
 
 void WebDataService::RemoveLoginsCreatedBetween(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);
-  ScheduleTask(Bind(&WebDataService::RemoveLoginsCreatedBetweenImpl,
-                    this, request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::RemoveLoginsCreatedBetweenImpl,
+                               this, request));
 }
 
 void WebDataService::RemoveLoginsCreatedAfter(const Time& delete_begin) {
   RemoveLoginsCreatedBetween(delete_begin, Time());
 }
 
 WebDataService::Handle WebDataService::GetLogins(
                                        const PasswordForm& form,
                                        WebDataServiceConsumer* consumer) {
   GenericRequest<PasswordForm>* request =
       new GenericRequest<PasswordForm>(this, GetNextRequestHandle(),
                                        consumer, form);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetLoginsImpl, this, request));
+  ScheduleTask(FROM_HERE, Bind(&WebDataService::GetLoginsImpl, this, request));
   return request->GetHandle();
 }
 
 WebDataService::Handle WebDataService::GetAutofillableLogins(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
       new WebDataRequest(this, GetNextRequestHandle(), consumer);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetAutofillableLoginsImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::GetAutofillableLoginsImpl, this, request));
   return request->GetHandle();
 }
 
 WebDataService::Handle WebDataService::GetBlacklistLogins(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
       new WebDataRequest(this, GetNextRequestHandle(), consumer);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetBlacklistLoginsImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::GetBlacklistLoginsImpl, this, request));
   return request->GetHandle();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Autofill.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::AddFormFields(
     const std::vector<FormField>& fields) {
   GenericRequest<std::vector<FormField> >* request =
       new GenericRequest<std::vector<FormField> >(
           this, GetNextRequestHandle(), NULL, fields);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::AddFormElementsImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::GetFormValuesForElementNameImpl,
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveFormElementsAddedBetweenImpl,
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::RemoveFormElementsAddedBetweenImpl,
                     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);
-  ScheduleTask(Bind(&WebDataService::RemoveFormValueForElementNameImpl,
+  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);
-  ScheduleTask(Bind(&WebDataService::AddAutofillProfileImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::UpdateAutofillProfileImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveAutofillProfileImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::RemoveAutofillProfileImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetAutofillProfiles(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
       new WebDataRequest(this, GetNextRequestHandle(), consumer);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetAutofillProfilesImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::EmptyMigrationTrashImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::AddCreditCardImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::UpdateCreditCardImpl, this, request));
+  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);
-  ScheduleTask(Bind(&WebDataService::RemoveCreditCardImpl, this, request));
+  ScheduleTask(FROM_HERE,
+               Bind(&WebDataService::RemoveCreditCardImpl, this, request));
 }
 
 WebDataService::Handle WebDataService::GetCreditCards(
     WebDataServiceConsumer* consumer) {
   WebDataRequest* request =
       new WebDataRequest(this, GetNextRequestHandle(), consumer);
   RegisterRequest(request);
-  ScheduleTask(Bind(&WebDataService::GetCreditCardsImpl, this, request));
+  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);
-  ScheduleTask(Bind(
+  ScheduleTask(FROM_HERE, Bind(
       &WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl,
-      this,
-      request));
+      this, request));
 }
 
 WebDataService::~WebDataService() {
   if (is_running_ && db_) {
     DLOG_ASSERT("WebDataService dtor called without Shutdown");
   }
 }
 
 bool WebDataService::InitWithPath(const FilePath& path) {
   path_ = path;
   is_running_ = true;
 
   // TODO(isherman): For now, to avoid a data race on shutdown
   // [ http://crbug.com/100745 ], call |AutofillCountry::ApplicationLocale()| to
   // cache the application locale before we try to access it on the DB thread.
   // This should be safe to remove once [ http://crbug.com/100845 ] is fixed.
   AutofillCountry::ApplicationLocale();
 
-  ScheduleTask(Bind(&WebDataService::InitializeDatabaseIfNecessary, this));
-  ScheduleTask(Bind(&WebDataService::InitializeSyncableServices, this));
+  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;
@@ skipping 117 matching lines @@
   if (should_commit_) {
     should_commit_ = false;
 
     if (db_) {
       db_->CommitTransaction();
       db_->BeginTransaction();
     }
   }
 }
 
-void WebDataService::ScheduleTask(const base::Closure& task) {
+void WebDataService::ScheduleTask(const tracked_objects::Location& from_here,
+                                  const base::Closure& task) {
   if (is_running_)
-    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, task);
+    BrowserThread::PostTask(BrowserThread::DB, from_here, task);
   else
     NOTREACHED() << "Task scheduled after Shutdown()";
 }
 
 void WebDataService::ScheduleCommit() {
   if (should_commit_ == false) {
     should_commit_ = true;
-    ScheduleTask(Bind(&WebDataService::Commit, this));
+    ScheduleTask(FROM_HERE, Bind(&WebDataService::Commit, this));
   }
 }
 
 int WebDataService::GetNextRequestHandle() {
   base::AutoLock l(pending_lock_);
   return ++next_request_handle_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ skipping 760 matching lines @@
 }
 
 const WDTypedResult* WebDataService::WebDataRequest::GetResult() const {
   return result_;
 }
 
 void WebDataService::WebDataRequest::RequestComplete() {
   message_loop_->PostTask(FROM_HERE, Bind(&WebDataService::RequestCompleted,
                                           service_.get(), handle_));
 }