Revert revision 176015

chrome/browser/extensions/api/history/history_api.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/extensions/api/history/history_api.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 250 matching lines @@
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&HistoryFunctionWithCallback::SendResponseToCallback, this));
 }
 
 void HistoryFunctionWithCallback::SendResponseToCallback() {
   SendResponse(true);
   Release();  // Balanced in RunImpl().
 }
 
-bool HistoryGetMostVisitedFunction::RunAsyncImpl() {
+bool GetMostVisitedHistoryFunction::RunAsyncImpl() {
   scoped_ptr<GetMostVisited::Params> params =
       GetMostVisited::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   history::VisitFilter filter;
   if (params->details.filter_time.get())
     filter.SetFilterTime(GetTime(*params->details.filter_time));
   if (params->details.filter_width.get()) {
     filter.SetFilterWidth(base::TimeDelta::FromMilliseconds(
         static_cast<int64>(*params->details.filter_width)));
   }
   if (params->details.day_of_the_week.get())
     filter.SetDayOfTheWeekFilter(*params->details.day_of_the_week);
   int max_results = 100;
   if (params->details.max_results.get())
     max_results = *params->details.max_results;
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(), Profile::EXPLICIT_ACCESS);
   hs->QueryFilteredURLs(max_results, filter, false, &cancelable_consumer_,
-      base::Bind(&HistoryGetMostVisitedFunction::QueryComplete,
+      base::Bind(&GetMostVisitedHistoryFunction::QueryComplete,
                  base::Unretained(this)));
   return true;
 }
 
-void HistoryGetMostVisitedFunction::QueryComplete(
+void GetMostVisitedHistoryFunction::QueryComplete(
     CancelableRequestProvider::Handle handle,
     const history::FilteredURLList& data) {
   std::vector<linked_ptr<MostVisitedItem> > results;
   results.reserve(data.size());
   for (size_t i = 0; i < data.size(); i++) {
     linked_ptr<MostVisitedItem> item(new MostVisitedItem);
     item->url = data[i].url.spec();
     item->title = UTF16ToUTF8(data[i].title);
     results.push_back(item);
   }
   results_ = GetMostVisited::Results::Create(results);
   SendAsyncResponse();
 }
 
-bool HistoryGetVisitsFunction::RunAsyncImpl() {
+bool GetVisitsHistoryFunction::RunAsyncImpl() {
   scoped_ptr<GetVisits::Params> params(GetVisits::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->QueryURL(url,
                true,  // Retrieve full history of a URL.
                &cancelable_consumer_,
-               base::Bind(&HistoryGetVisitsFunction::QueryComplete,
+               base::Bind(&GetVisitsHistoryFunction::QueryComplete,
                           base::Unretained(this)));
 
   return true;
 }
 
-void HistoryGetVisitsFunction::QueryComplete(
+void GetVisitsHistoryFunction::QueryComplete(
     HistoryService::Handle request_service,
     bool success,
     const history::URLRow* url_row,
     history::VisitVector* visits) {
   VisitItemList visit_item_vec;
   if (visits && !visits->empty()) {
     for (history::VisitVector::iterator iterator = visits->begin();
          iterator != visits->end();
          ++iterator) {
       visit_item_vec.push_back(make_linked_ptr(
           GetVisitItem(*iterator).release()));
     }
   }
 
   results_ = GetVisits::Results::Create(visit_item_vec);
   SendAsyncResponse();
 }
 
-bool HistorySearchFunction::RunAsyncImpl() {
+bool SearchHistoryFunction::RunAsyncImpl() {
   scoped_ptr<Search::Params> params(Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   string16 search_text = UTF8ToUTF16(params->query.text);
 
   history::QueryOptions options;
   options.SetRecentDayRange(1);
   options.max_count = 100;
 
   if (params->query.start_time.get())
     options.begin_time = GetTime(*params->query.start_time);
   if (params->query.end_time.get())
     options.end_time = GetTime(*params->query.end_time);
   if (params->query.max_results.get())
     options.max_count = *params->query.max_results;
 
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->QueryHistory(search_text, options, &cancelable_consumer_,
-                   base::Bind(&HistorySearchFunction::SearchComplete,
+                   base::Bind(&SearchHistoryFunction::SearchComplete,
                               base::Unretained(this)));
 
   return true;
 }
 
-void HistorySearchFunction::SearchComplete(
+void SearchHistoryFunction::SearchComplete(
     HistoryService::Handle request_handle,
     history::QueryResults* results) {
   HistoryItemList history_item_vec;
   if (results && !results->empty()) {
     for (history::QueryResults::URLResultVector::const_iterator iterator =
             results->begin();
          iterator != results->end();
         ++iterator) {
       history_item_vec.push_back(make_linked_ptr(
           GetHistoryItem(**iterator).release()));
     }
   }
   results_ = Search::Results::Create(history_item_vec);
   SendAsyncResponse();
 }
 
-bool HistoryAddUrlFunction::RunImpl() {
+bool AddUrlHistoryFunction::RunImpl() {
   scoped_ptr<AddUrl::Params> params(AddUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->AddPage(url, base::Time::Now(), history::SOURCE_EXTENSION);
 
   SendResponse(true);
   return true;
 }
 
-bool HistoryDeleteUrlFunction::RunImpl() {
+bool DeleteUrlHistoryFunction::RunImpl() {
   scoped_ptr<DeleteUrl::Params> params(DeleteUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url;
   if (!ValidateUrl(params->details.url, &url))
     return false;
 
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->DeleteURL(url);
 
   SendResponse(true);
   return true;
 }
 
-bool HistoryDeleteRangeFunction::RunAsyncImpl() {
+bool DeleteRangeHistoryFunction::RunAsyncImpl() {
   scoped_ptr<DeleteRange::Params> params(DeleteRange::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::Time start_time = GetTime(params->range.start_time);
   base::Time end_time = GetTime(params->range.end_time);
 
   std::set<GURL> restrict_urls;
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->ExpireHistoryBetween(
       restrict_urls,
       start_time,
       end_time,
-      base::Bind(&HistoryDeleteRangeFunction::DeleteComplete,
+      base::Bind(&DeleteRangeHistoryFunction::DeleteComplete,
                  base::Unretained(this)),
       &task_tracker_);
 
   return true;
 }
 
-void HistoryDeleteRangeFunction::DeleteComplete() {
+void DeleteRangeHistoryFunction::DeleteComplete() {
   SendAsyncResponse();
 }
 
-bool HistoryDeleteAllFunction::RunAsyncImpl() {
+bool DeleteAllHistoryFunction::RunAsyncImpl() {
   std::set<GURL> restrict_urls;
   HistoryService* hs =
       HistoryServiceFactory::GetForProfile(profile(),
                                            Profile::EXPLICIT_ACCESS);
   hs->ExpireHistoryBetween(
       restrict_urls,
       base::Time::UnixEpoch(),     // From the beginning of the epoch.
       base::Time::Now(),           // To the current time.
-      base::Bind(&HistoryDeleteAllFunction::DeleteComplete,
+      base::Bind(&DeleteAllHistoryFunction::DeleteComplete,
                  base::Unretained(this)),
       &task_tracker_);
 
   return true;
 }
 
-void HistoryDeleteAllFunction::DeleteComplete() {
+void DeleteAllHistoryFunction::DeleteComplete() {
   SendAsyncResponse();
 }
 
 }  // namespace extensions