Fix WebDataRequest ownership gap

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()),
       app_locale_(AutofillCountry::ApplicationLocale()),
       autocomplete_syncable_service_(NULL),
       autofill_profile_syncable_service_(NULL),
       failed_init_(false),
       should_commit_(false),
       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));
@@ skipping 27 matching lines @@
 
 bool WebDataService::IsRunning() const {
   return is_running_;
 }
 
 void WebDataService::UnloadDatabase() {
   ScheduleTask(FROM_HERE, Bind(&WebDataService::ShutdownDatabase, this));
 }
 
 void WebDataService::CancelRequest(Handle h) {
-  request_manager_.CancelRequest(h);
+  request_manager_->CancelRequest(h);
 }
 
 content::NotificationSource WebDataService::GetNotificationSource() {
   return content::Source<WebDataService>(this);
 }
 
 bool WebDataService::IsDatabaseLoaded() {
   return db_ != NULL;
 }
 
@@ skipping 274 matching lines @@
   path_ = path;
   is_running_ = true;
 
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::InitializeDatabaseIfNecessary, this));
   ScheduleTask(FROM_HERE,
                Bind(&WebDataService::InitializeSyncableServices, this));
   return true;
 }
 
-void WebDataService::RequestCompleted(Handle h) {
-  request_manager_.RequestCompleted(h);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 //
 // The following methods are executed in Chrome_WebDataThread.
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void WebDataService::DBInitFailed(sql::InitStatus init_status) {
   ShowProfileErrorDialog(
       (init_status == sql::INIT_FAILURE) ?
       IDS_COULDNT_OPEN_PROFILE_ERROR : IDS_PROFILE_TOO_NEW_ERROR);
@@ skipping 80 matching lines @@
                                   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_);
+  scoped_ptr<WebDataRequest> request(
+      new WebDataRequest(NULL, request_manager_.get()));
   if (is_running_) {
     BrowserThread::PostTask(BrowserThread::DB, from_here,
-        base::Bind(&WebDataService::DBTaskWrapper, this, task, request));
+        base::Bind(&WebDataService::DBTaskWrapper, this, task,
+                   base::Passed(&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_);
+  scoped_ptr<WebDataRequest> request(
+      new WebDataRequest(consumer, request_manager_.get()));
+  WebDataService::Handle handle = request->GetHandle();
   if (is_running_) {
     BrowserThread::PostTask(BrowserThread::DB, from_here,
-        base::Bind(&WebDataService::DBResultTaskWrapper, this, task, request));
+        base::Bind(&WebDataService::DBResultTaskWrapper, this, task,
+                   base::Passed(&request)));
   } else {
     NOTREACHED() << "Task scheduled after Shutdown()";
   }
-  return request->GetHandle();
+  return handle;
 }
 
 void WebDataService::DBTaskWrapper(const base::Closure& task,
-                                   WebDataRequest* request) {
+                                   scoped_ptr<WebDataRequest> request) {
   InitializeDatabaseIfNecessary();
   if (db_ && !request->IsCancelled()) {
     task.Run();
   }
-  request->RequestComplete();
+  request_manager_->RequestCompleted(request.Pass());
 }
 
 void WebDataService::DBResultTaskWrapper(const ResultTask& task,
-                                         WebDataRequest* request) {
+                                         scoped_ptr<WebDataRequest> request) {
   InitializeDatabaseIfNecessary();
   if (db_ && !request->IsCancelled()) {
-    request->SetResult(task.Run().Pass());
+    request->SetResult(task.Run());
   }
-  request->RequestComplete();
+  request_manager_->RequestCompleted(request.Pass());
 }
 
 void WebDataService::ScheduleCommit() {
   if (should_commit_ == false) {
     should_commit_ = true;
     ScheduleTask(FROM_HERE, Bind(&WebDataService::Commit, this));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 334 matching lines @@
   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*> >(
+      new WDDestroyableResult<std::vector<AutofillProfile*> >(
           AUTOFILL_PROFILES_RESULT,
+          profiles,
           base::Bind(&WebDataService::DestroyAutofillProfileResult,
-              base::Unretained(this)),
-          profiles));
+              base::Unretained(this))));
 }
 
 void WebDataService::EmptyMigrationTrashImpl(bool notify_sync) {
   if (notify_sync) {
     std::vector<std::string> guids;
     if (!db_->GetAutofillTable()->GetAutofillProfilesInTrash(&guids)) {
       NOTREACHED();
       return;
     }
 
@@ skipping 88 matching lines @@
   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*> >(
+      new WDDestroyableResult<std::vector<CreditCard*> >(
           AUTOFILL_CREDITCARDS_RESULT,
+          credit_cards,
           base::Bind(&WebDataService::DestroyAutofillCreditCardResult,
-              base::Unretained(this)),
-          credit_cards));
+              base::Unretained(this))));
 }
 
 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,
@@ skipping 50 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);
 }