Don't leak WebHistoryService::Request on HistoryService shutdown.

chrome/browser/history/web_history_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/history/web_history_service.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
@@ skipping 276 matching lines @@
 
 WebHistoryService::Request::~Request() {
 }
 
 WebHistoryService::WebHistoryService(Profile* profile)
     : profile_(profile),
       weak_ptr_factory_(this) {
 }
 
 WebHistoryService::~WebHistoryService() {
+  STLDeleteElements(&pending_expire_requests_);
 }
 
 scoped_ptr<WebHistoryService::Request> WebHistoryService::QueryHistory(
     const base::string16& text_query,
     const QueryOptions& options,
     const WebHistoryService::QueryWebHistoryCallback& callback) {
   // Wrap the original callback into a generic completion callback.
   RequestImpl::CompletionCallback completion_callback = base::Bind(
       &WebHistoryService::QueryHistoryCompletionCallback, callback);
 
   GURL url = GetQueryUrl(text_query, options, server_version_info_);
   scoped_ptr<RequestImpl> request(
       new RequestImpl(profile_, url, completion_callback));
   request->Start();
   return request.PassAs<Request>();
 }
 
-scoped_ptr<WebHistoryService::Request> WebHistoryService::ExpireHistory(
+void WebHistoryService::ExpireHistory(
     const std::vector<ExpireHistoryArgs>& expire_list,
     const ExpireWebHistoryCallback& callback) {
   base::DictionaryValue delete_request;
   scoped_ptr<base::ListValue> deletions(new base::ListValue);
   base::Time now = base::Time::Now();
 
   for (std::vector<ExpireHistoryArgs>::const_iterator it = expire_list.begin();
        it != expire_list.end(); ++it) {
     // Convert the times to server timestamps.
     std::string min_timestamp = ServerTimeString(it->begin_time);
@@ skipping 26 matching lines @@
   // Wrap the original callback into a generic completion callback.
   RequestImpl::CompletionCallback completion_callback =
       base::Bind(&WebHistoryService::ExpireHistoryCompletionCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback);
 
   scoped_ptr<RequestImpl> request(
       new RequestImpl(profile_, url, completion_callback));
   request->set_post_data(post_data);
   request->Start();
-  return request.PassAs<Request>();
+  pending_expire_requests_.insert(request.release());
 }
 
-scoped_ptr<WebHistoryService::Request> WebHistoryService::ExpireHistoryBetween(
+void WebHistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     base::Time begin_time,
     base::Time end_time,
     const ExpireWebHistoryCallback& callback) {
   std::vector<ExpireHistoryArgs> expire_list(1);
   expire_list.back().urls = restrict_urls;
   expire_list.back().begin_time = begin_time;
   expire_list.back().end_time = end_time;
-  return ExpireHistory(expire_list, callback);
+  ExpireHistory(expire_list, callback);
 }
 
 // static
 void WebHistoryService::QueryHistoryCompletionCallback(
     const WebHistoryService::QueryWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
   scoped_ptr<base::DictionaryValue> response_value;
   if (success)
     response_value = ReadResponse(static_cast<RequestImpl*>(request));
   callback.Run(request, response_value.get());
 }
 
 void WebHistoryService::ExpireHistoryCompletionCallback(
     const WebHistoryService::ExpireWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
   scoped_ptr<base::DictionaryValue> response_value;
   if (success) {
     response_value = ReadResponse(static_cast<RequestImpl*>(request));
     if (response_value)
       response_value->GetString("version_info", &server_version_info_);
   }
-  callback.Run(request, response_value.get() && success);
+  callback.Run(response_value.get() && success);
+  // Clean up from pending requests.
+  pending_expire_requests_.erase(request);
+  delete request;
 }
 
 }  // namespace history