Move history extension API implementation to history dir.

chrome/browser/history/history_extension_api.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/extensions/extension_history_api.h"
+#include "chrome/browser/history/history_extension_api.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
-#include "chrome/browser/extensions/extension_history_api_constants.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
-namespace keys = extension_history_api_constants;
+namespace {
 
-namespace {
+const char kAllHistoryKey[] = "allHistory";
+const char kEndTimeKey[] = "endTime";
+const char kFaviconUrlKey[] = "favIconUrl";
+const char kIdKey[] = "id";
+const char kLastVisitdKey[] = "lastVisitTime";
+const char kMaxResultsKey[] = "maxResults";
+const char kNewKey[] = "new";
+const char kReferringVisitId[] = "referringVisitId";
+const char kRemovedKey[] = "removed";
+const char kStartTimeKey[] = "startTime";
+const char kTextKey[] = "text";
+const char kTitleKey[] = "title";
+const char kTypedCountKey[] = "typedCount";
+const char kVisitCountKey[] = "visitCount";
+const char kTransition[] = "transition";
+const char kUrlKey[] = "url";
+const char kUrlsKey[] = "urls";
+const char kVisitId[] = "visitId";
+const char kVisitTime[] = "visitTime";
+
+const char kOnVisited[] = "history.onVisited";
+const char kOnVisitRemoved[] = "history.onVisitRemoved";
+
+const char kInvalidIdError[] = "History item id is invalid.";
+const char kInvalidUrlError[] = "Url is invalid.";
 
 double MilliSecondsFromTime(const base::Time& time) {
   return 1000 * time.ToDoubleT();
 }
 
 void GetHistoryItemDictionary(const history::URLRow& row,
                               DictionaryValue* value) {
-  value->SetString(keys::kIdKey, base::Int64ToString(row.id()));
-  value->SetString(keys::kUrlKey, row.url().spec());
-  value->SetString(keys::kTitleKey, row.title());
-  value->SetDouble(keys::kLastVisitdKey,
+  value->SetString(kIdKey, base::Int64ToString(row.id()));
+  value->SetString(kUrlKey, row.url().spec());
+  value->SetString(kTitleKey, row.title());
+  value->SetDouble(kLastVisitdKey,
                    MilliSecondsFromTime(row.last_visit()));
-  value->SetInteger(keys::kTypedCountKey, row.typed_count());
-  value->SetInteger(keys::kVisitCountKey, row.visit_count());
+  value->SetInteger(kTypedCountKey, row.typed_count());
+  value->SetInteger(kVisitCountKey, row.visit_count());
 }
 
 void AddHistoryNode(const history::URLRow& row, ListValue* list) {
   DictionaryValue* dict = new DictionaryValue();
   GetHistoryItemDictionary(row, dict);
   list->Append(dict);
 }
 
 void GetVisitInfoDictionary(const history::VisitRow& row,
                             DictionaryValue* value) {
-  value->SetString(keys::kIdKey, base::Int64ToString(row.url_id));
-  value->SetString(keys::kVisitId, base::Int64ToString(row.visit_id));
-  value->SetDouble(keys::kVisitTime, MilliSecondsFromTime(row.visit_time));
-  value->SetString(keys::kReferringVisitId,
+  value->SetString(kIdKey, base::Int64ToString(row.url_id));
+  value->SetString(kVisitId, base::Int64ToString(row.visit_id));
+  value->SetDouble(kVisitTime, MilliSecondsFromTime(row.visit_time));
+  value->SetString(kReferringVisitId,
                    base::Int64ToString(row.referring_visit));
 
   const char* trans =
       content::PageTransitionGetCoreTransitionString(row.transition);
   DCHECK(trans) << "Invalid transition.";
-  value->SetString(keys::kTransition, trans);
+  value->SetString(kTransition, trans);
 }
 
 void AddVisitNode(const history::VisitRow& row, ListValue* list) {
   DictionaryValue* dict = new DictionaryValue();
   GetVisitInfoDictionary(row, dict);
   list->Append(dict);
 }
 
 }  // namespace
 
-ExtensionHistoryEventRouter::ExtensionHistoryEventRouter() {}
+HistoryExtensionEventRouter::HistoryExtensionEventRouter() {}
 
-ExtensionHistoryEventRouter::~ExtensionHistoryEventRouter() {}
+HistoryExtensionEventRouter::~HistoryExtensionEventRouter() {}
 
-void ExtensionHistoryEventRouter::ObserveProfile(Profile* profile) {
+void HistoryExtensionEventRouter::ObserveProfile(Profile* profile) {
   CHECK(registrar_.IsEmpty());
   const content::Source<Profile> source = content::Source<Profile>(profile);
   registrar_.Add(this,
                  chrome::NOTIFICATION_HISTORY_URL_VISITED,
                  source);
   registrar_.Add(this,
                  chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                  source);
 }
 
-void ExtensionHistoryEventRouter::Observe(
+void HistoryExtensionEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_HISTORY_URL_VISITED:
       HistoryUrlVisited(
           content::Source<Profile>(source).ptr(),
           content::Details<const history::URLVisitedDetails>(details).ptr());
       break;
     case chrome::NOTIFICATION_HISTORY_URLS_DELETED:
       HistoryUrlsRemoved(
           content::Source<Profile>(source).ptr(),
           content::Details<const history::URLsDeletedDetails>(details).ptr());
       break;
     default:
       NOTREACHED();
   }
 }
 
-void ExtensionHistoryEventRouter::HistoryUrlVisited(
+void HistoryExtensionEventRouter::HistoryUrlVisited(
     Profile* profile,
     const history::URLVisitedDetails* details) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   GetHistoryItemDictionary(details->row, dict);
   args.Append(dict);
 
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
-  DispatchEvent(profile, keys::kOnVisited, json_args);
+  DispatchEvent(profile, kOnVisited, json_args);
 }
 
-void ExtensionHistoryEventRouter::HistoryUrlsRemoved(
+void HistoryExtensionEventRouter::HistoryUrlsRemoved(
     Profile* profile,
     const history::URLsDeletedDetails* details) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
-  dict->SetBoolean(keys::kAllHistoryKey, details->all_history);
+  dict->SetBoolean(kAllHistoryKey, details->all_history);
   ListValue* urls = new ListValue();
   for (std::set<GURL>::const_iterator iterator = details->urls.begin();
       iterator != details->urls.end();
       ++iterator) {
     urls->Append(new StringValue(iterator->spec()));
   }
-  dict->Set(keys::kUrlsKey, urls);
+  dict->Set(kUrlsKey, urls);
   args.Append(dict);
 
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
-  DispatchEvent(profile, keys::kOnVisitRemoved, json_args);
+  DispatchEvent(profile, kOnVisitRemoved, json_args);
 }
 
-void ExtensionHistoryEventRouter::DispatchEvent(Profile* profile,
+void HistoryExtensionEventRouter::DispatchEvent(Profile* profile,
                                                 const char* event_name,
                                                 const std::string& json_args) {
   if (profile && profile->GetExtensionEventRouter()) {
     profile->GetExtensionEventRouter()->DispatchEventToRenderers(
         event_name, json_args, profile, GURL());
   }
 }
 
 void HistoryFunction::Run() {
   if (!RunImpl()) {
     SendResponse(false);
   }
 }
 
 bool HistoryFunction::GetUrlFromValue(Value* value, GURL* url) {
   std::string url_string;
   if (!value->GetAsString(&url_string)) {
     bad_message_ = true;
     return false;
   }
 
   GURL temp_url(url_string);
   if (!temp_url.is_valid()) {
-    error_ = keys::kInvalidUrlError;
+    error_ = kInvalidUrlError;
     return false;
   }
   url->Swap(&temp_url);
   return true;
 }
 
 bool HistoryFunction::GetTimeFromValue(Value* value, base::Time* time) {
   double ms_from_epoch = 0.0;
   if (!value->GetAsDouble(&ms_from_epoch))
     return false;
@@ skipping 32 matching lines @@
 void HistoryFunctionWithCallback::SendResponseToCallback() {
   SendResponse(true);
   Release();  // Balanced in RunImpl().
 }
 
 bool GetVisitsHistoryFunction::RunAsyncImpl() {
   DictionaryValue* json;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &json));
 
   Value* value;
-  EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kUrlKey, &value));
+  EXTENSION_FUNCTION_VALIDATE(json->Get(kUrlKey, &value));
 
   GURL url;
   if (!GetUrlFromValue(value, &url))
     return false;
 
   HistoryService* hs = profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->QueryURL(url,
                true,  // Retrieve full history of a URL.
                &cancelable_consumer_,
                base::Bind(&GetVisitsHistoryFunction::QueryComplete,
@@ skipping 18 matching lines @@
   result_.reset(list);
   SendAsyncResponse();
 }
 
 bool SearchHistoryFunction::RunAsyncImpl() {
   DictionaryValue* json;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &json));
 
   // Initialize the HistoryQuery
   string16 search_text;
-  EXTENSION_FUNCTION_VALIDATE(json->GetString(keys::kTextKey, &search_text));
+  EXTENSION_FUNCTION_VALIDATE(json->GetString(kTextKey, &search_text));
 
   history::QueryOptions options;
   options.SetRecentDayRange(1);
   options.max_count = 100;
 
-  if (json->HasKey(keys::kStartTimeKey)) {  // Optional.
+  if (json->HasKey(kStartTimeKey)) {  // Optional.
     Value* value;
-    EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kStartTimeKey, &value));
+    EXTENSION_FUNCTION_VALIDATE(json->Get(kStartTimeKey, &value));
     EXTENSION_FUNCTION_VALIDATE(GetTimeFromValue(value, &options.begin_time));
   }
-  if (json->HasKey(keys::kEndTimeKey)) {  // Optional.
+  if (json->HasKey(kEndTimeKey)) {  // Optional.
     Value* value;
-    EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kEndTimeKey, &value));
+    EXTENSION_FUNCTION_VALIDATE(json->Get(kEndTimeKey, &value));
     EXTENSION_FUNCTION_VALIDATE(GetTimeFromValue(value, &options.end_time));
   }
-  if (json->HasKey(keys::kMaxResultsKey)) {  // Optional.
-    EXTENSION_FUNCTION_VALIDATE(json->GetInteger(keys::kMaxResultsKey,
+  if (json->HasKey(kMaxResultsKey)) {  // Optional.
+    EXTENSION_FUNCTION_VALIDATE(json->GetInteger(kMaxResultsKey,
                                                  &options.max_count));
   }
 
   HistoryService* hs = profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->QueryHistory(search_text, options, &cancelable_consumer_,
                    base::Bind(&SearchHistoryFunction::SearchComplete,
                               base::Unretained(this)));
 
   return true;
 }
@@ skipping 12 matching lines @@
   }
   result_.reset(list);
   SendAsyncResponse();
 }
 
 bool AddUrlHistoryFunction::RunImpl() {
   DictionaryValue* json;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &json));
 
   Value* value;
-  EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kUrlKey, &value));
+  EXTENSION_FUNCTION_VALIDATE(json->Get(kUrlKey, &value));
 
   GURL url;
   if (!GetUrlFromValue(value, &url))
     return false;
 
   HistoryService* hs = profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->AddPage(url, history::SOURCE_EXTENSION);
 
   SendResponse(true);
   return true;
 }
 
 bool DeleteUrlHistoryFunction::RunImpl() {
   DictionaryValue* json;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &json));
 
   Value* value;
-  EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kUrlKey, &value));
+  EXTENSION_FUNCTION_VALIDATE(json->Get(kUrlKey, &value));
 
   GURL url;
   if (!GetUrlFromValue(value, &url))
     return false;
 
   HistoryService* hs = profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->DeleteURL(url);
 
   SendResponse(true);
   return true;
 }
 
 bool DeleteRangeHistoryFunction::RunAsyncImpl() {
   DictionaryValue* json;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &json));
 
   Value* value = NULL;
-  EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kStartTimeKey, &value));
+  EXTENSION_FUNCTION_VALIDATE(json->Get(kStartTimeKey, &value));
   base::Time begin_time;
   EXTENSION_FUNCTION_VALIDATE(GetTimeFromValue(value, &begin_time));
 
-  EXTENSION_FUNCTION_VALIDATE(json->Get(keys::kEndTimeKey, &value));
+  EXTENSION_FUNCTION_VALIDATE(json->Get(kEndTimeKey, &value));
   base::Time end_time;
   EXTENSION_FUNCTION_VALIDATE(GetTimeFromValue(value, &end_time));
 
   std::set<GURL> restrict_urls;
   HistoryService* hs = profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   hs->ExpireHistoryBetween(
       restrict_urls,
       begin_time,
       end_time,
       &cancelable_consumer_,
@@ skipping 17 matching lines @@
       &cancelable_consumer_,
       base::Bind(&DeleteAllHistoryFunction::DeleteComplete,
                  base::Unretained(this)));
 
   return true;
 }
 
 void DeleteAllHistoryFunction::DeleteComplete() {
   SendAsyncResponse();
 }