Move download extension api implementation to download/ dir.

chrome/browser/download/download_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_downloads_api.h"
+#include "chrome/browser/download/download_extension_api.h"
 
 #include <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_util.h"
-#include "chrome/browser/extensions/extension_downloads_api_constants.h"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_item.h"
 #include "content/browser/download/download_types.h"
 #include "content/browser/download/interrupt_reasons.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 
-namespace constants = extension_downloads_api_constants;
+namespace {
+
+// Error messages
+const char kNotImplemented[] = "NotImplemented";
+const char kGenericError[] = "I'm afraid I can't do that.";
+const char kInvalidURL[] = "Invalid URL";
+
+// Parameter keys
+const char kBodyKey[] = "body";
+const char kBytesReceivedKey[] = "bytesReceived";
+const char kDangerAcceptedKey[] = "dangerAccepted";
+const char kDangerFile[] = "file";
+const char kDangerKey[] = "danger";
+const char kDangerSafe[] = "safe";
+const char kDangerUrl[] = "url";
+const char kEndTimeKey[] = "endTime";
+const char kErrorKey[] = "error";
+const char kFileSizeKey[] = "fileSize";
+const char kFilenameKey[] = "filename";
+const char kHeaderNameKey[] = "name";
+const char kHeaderValueKey[] = "value";
+const char kHeadersKey[] = "headers";
+const char kIdKey[] = "id";
+const char kMethodKey[] = "method";
+const char kMimeKey[] = "mime";
+const char kPausedKey[] = "paused";
+const char kSaveAsKey[] = "saveAs";
+const char kStartTimeKey[] = "startTime";
+const char kStateComplete[] = "complete";
+const char kStateInProgress[] = "in_progress";
+const char kStateInterrupted[] = "interrupted";
+const char kStateKey[] = "state";
+const char kTotalBytesKey[] = "totalBytes";
+const char kUrlKey[] = "url";
+
+const char* DangerString(DownloadItem::DangerType danger) {
+  switch (danger) {
+    case DownloadItem::NOT_DANGEROUS: return kDangerSafe;
+    case DownloadItem::DANGEROUS_FILE: return kDangerFile;
+    case DownloadItem::DANGEROUS_URL: return kDangerUrl;
+    default:
+      NOTREACHED();
+      return "";
+  }
+}
+
+const char* StateString(DownloadItem::DownloadState state) {
+  switch (state) {
+    case DownloadItem::IN_PROGRESS: return kStateInProgress;
+    case DownloadItem::COMPLETE: return kStateComplete;
+    case DownloadItem::INTERRUPTED:  // fall through
+    case DownloadItem::CANCELLED: return kStateInterrupted;
+    case DownloadItem::REMOVING:  // fall through
+    default:
+      NOTREACHED();
+      return "";
+  }
+}
+
+}  // namespace
 
 bool DownloadsFunctionInterface::RunImplImpl(
     DownloadsFunctionInterface* pimpl) {
   CHECK(pimpl);
   if (!pimpl->ParseArgs()) return false;
   UMA_HISTOGRAM_ENUMERATION(
       "Download.ApiFunctions", pimpl->function(), DOWNLOADS_FUNCTION_LAST);
   pimpl->RunInternal();
   return true;
 }
@@ skipping 46 matching lines @@
     render_view_host_routing_id(0) {
 }
 
 DownloadsDownloadFunction::IOData::~IOData() {}
 
 bool DownloadsDownloadFunction::ParseArgs() {
   base::DictionaryValue* options = NULL;
   std::string url;
   iodata_.reset(new IOData());
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
-  EXTENSION_FUNCTION_VALIDATE(options->GetString(constants::kUrlKey, &url));
+  EXTENSION_FUNCTION_VALIDATE(options->GetString(kUrlKey, &url));
   iodata_->url = GURL(url);
   if (!iodata_->url.is_valid()) {
-    error_ = constants::kInvalidURL;
+    error_ = kInvalidURL;
     return false;
   }
-  if (options->HasKey(constants::kFilenameKey))
+  if (options->HasKey(kFilenameKey))
     EXTENSION_FUNCTION_VALIDATE(options->GetString(
-        constants::kFilenameKey, &iodata_->filename));
+        kFilenameKey, &iodata_->filename));
   // TODO(benjhayden): More robust validation of filename.
   if (((iodata_->filename[0] == L'.') && (iodata_->filename[1] == L'.')) ||
       (iodata_->filename[0] == L'/')) {
-    error_ = constants::kGenericError;
+    error_ = kGenericError;
     return false;
   }
-  if (options->HasKey(constants::kSaveAsKey))
+  if (options->HasKey(kSaveAsKey))
     EXTENSION_FUNCTION_VALIDATE(options->GetBoolean(
-        constants::kSaveAsKey, &iodata_->save_as));
-  if (options->HasKey(constants::kMethodKey))
+        kSaveAsKey, &iodata_->save_as));
+  if (options->HasKey(kMethodKey))
     EXTENSION_FUNCTION_VALIDATE(options->GetString(
-        constants::kMethodKey, &iodata_->method));
+        kMethodKey, &iodata_->method));
   // It's ok to use a pointer to extra_headers without DeepCopy()ing because
   // |args_| (which owns *extra_headers) is guaranteed to live as long as
   // |this|.
-  if (options->HasKey(constants::kHeadersKey))
+  if (options->HasKey(kHeadersKey))
     EXTENSION_FUNCTION_VALIDATE(options->GetList(
-        constants::kHeadersKey, &iodata_->extra_headers));
-  if (options->HasKey(constants::kBodyKey))
+        kHeadersKey, &iodata_->extra_headers));
+  if (options->HasKey(kBodyKey))
     EXTENSION_FUNCTION_VALIDATE(options->GetString(
-        constants::kBodyKey, &iodata_->post_body));
+        kBodyKey, &iodata_->post_body));
   if (iodata_->extra_headers != NULL) {
     for (size_t index = 0; index < iodata_->extra_headers->GetSize(); ++index) {
       base::DictionaryValue* header = NULL;
       std::string name, value;
       EXTENSION_FUNCTION_VALIDATE(iodata_->extra_headers->GetDictionary(
             index, &header));
       EXTENSION_FUNCTION_VALIDATE(header->GetString(
-            constants::kHeaderNameKey, &name));
+            kHeaderNameKey, &name));
       EXTENSION_FUNCTION_VALIDATE(header->GetString(
-            constants::kHeaderValueKey, &value));
+            kHeaderValueKey, &value));
       if (!net::HttpUtil::IsSafeHeader(name)) {
-        error_ = constants::kGenericError;
+        error_ = kGenericError;
         return false;
       }
     }
   }
   iodata_->rdh = g_browser_process->resource_dispatcher_host();
   iodata_->resource_context = &profile()->GetResourceContext();
   iodata_->render_process_host_id = render_view_host()->process()->id();
   iodata_->render_view_host_routing_id = render_view_host()->routing_id();
   return true;
 }
 
 void DownloadsDownloadFunction::RunInternal() {
   VLOG(1) << __FUNCTION__ << " " << iodata_->url.spec();
   if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
           &DownloadsDownloadFunction::BeginDownloadOnIOThread, this))) {
-    error_ = constants::kGenericError;
+    error_ = kGenericError;
     SendResponse(error_.empty());
   }
 }
 
 void DownloadsDownloadFunction::BeginDownloadOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << iodata_->url.spec();
   DownloadSaveInfo save_info;
   // TODO(benjhayden) Ensure that this filename is interpreted as a path
   // relative to the default downloads directory without allowing '..'.
@@ skipping 46 matching lines @@
 
 DownloadsSearchFunction::DownloadsSearchFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_SEARCH) {
 }
 
 DownloadsSearchFunction::~DownloadsSearchFunction() {}
 
 bool DownloadsSearchFunction::ParseArgs() {
   base::DictionaryValue* query_json = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &query_json));
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsSearchFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsPauseFunction::DownloadsPauseFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_PAUSE) {
 }
 
 DownloadsPauseFunction::~DownloadsPauseFunction() {}
 
 bool DownloadsPauseFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsPauseFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsResumeFunction::DownloadsResumeFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_RESUME) {
 }
 
 DownloadsResumeFunction::~DownloadsResumeFunction() {}
 
 bool DownloadsResumeFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsResumeFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_CANCEL) {
 }
 
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
 bool DownloadsCancelFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsCancelFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_ERASE) {
 }
 
 DownloadsEraseFunction::~DownloadsEraseFunction() {}
 
 bool DownloadsEraseFunction::ParseArgs() {
   base::DictionaryValue* query_json = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &query_json));
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsEraseFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsSetDestinationFunction::DownloadsSetDestinationFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_SET_DESTINATION) {
 }
 
 DownloadsSetDestinationFunction::~DownloadsSetDestinationFunction() {}
 
 bool DownloadsSetDestinationFunction::ParseArgs() {
   int dl_id = 0;
   std::string path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &path));
   VLOG(1) << __FUNCTION__ << " " << dl_id << " " << &path;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsSetDestinationFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_ACCEPT_DANGER) {
 }
 
 DownloadsAcceptDangerFunction::~DownloadsAcceptDangerFunction() {}
 
 bool DownloadsAcceptDangerFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsAcceptDangerFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsShowFunction::DownloadsShowFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_SHOW) {
 }
 
 DownloadsShowFunction::~DownloadsShowFunction() {}
 
 bool DownloadsShowFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsShowFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 DownloadsDragFunction::DownloadsDragFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_DRAG) {
 }
 
 DownloadsDragFunction::~DownloadsDragFunction() {}
 
 bool DownloadsDragFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
   VLOG(1) << __FUNCTION__ << " " << dl_id;
-  error_ = constants::kNotImplemented;
+  error_ = kNotImplemented;
   return false;
 }
 
 void DownloadsDragFunction::RunInternal() {
   NOTIMPLEMENTED();
 }
 
 namespace {
 base::DictionaryValue* DownloadItemToJSON(DownloadItem* item) {
   base::DictionaryValue* json = new base::DictionaryValue();
-  json->SetInteger(constants::kIdKey, item->id());
-  json->SetString(constants::kUrlKey, item->original_url().spec());
-  json->SetString(constants::kFilenameKey,
-                  item->full_path().LossyDisplayName());
-  json->SetString(constants::kDangerKey,
-                  constants::DangerString(item->GetDangerType()));
-  json->SetBoolean(constants::kDangerAcceptedKey,
+  json->SetInteger(kIdKey, item->id());
+  json->SetString(kUrlKey, item->original_url().spec());
+  json->SetString(kFilenameKey, item->full_path().LossyDisplayName());
+  json->SetString(kDangerKey, DangerString(item->GetDangerType()));
+  json->SetBoolean(kDangerAcceptedKey,
       item->safety_state() == DownloadItem::DANGEROUS_BUT_VALIDATED);
-  json->SetString(constants::kStateKey,
-                  constants::StateString(item->state()));
-  json->SetBoolean(constants::kPausedKey, item->is_paused());
-  json->SetString(constants::kMimeKey, item->mime_type());
-  json->SetInteger(constants::kStartTimeKey,
+  json->SetString(kStateKey, StateString(item->state()));
+  json->SetBoolean(kPausedKey, item->is_paused());
+  json->SetString(kMimeKey, item->mime_type());
+  json->SetInteger(kStartTimeKey,
       (item->start_time() - base::Time::UnixEpoch()).InMilliseconds());
-  json->SetInteger(constants::kBytesReceivedKey, item->received_bytes());
-  json->SetInteger(constants::kTotalBytesKey, item->total_bytes());
+  json->SetInteger(kBytesReceivedKey, item->received_bytes());
+  json->SetInteger(kTotalBytesKey, item->total_bytes());
   if (item->state() == DownloadItem::INTERRUPTED)
-    json->SetInteger(constants::kErrorKey,
-                     static_cast<int>(item->last_reason()));
+    json->SetInteger(kErrorKey, static_cast<int>(item->last_reason()));
   // TODO(benjhayden): Implement endTime and fileSize.
-  // json->SetInteger(constants::kEndTimeKey, -1);
-  json->SetInteger(constants::kFileSizeKey, item->total_bytes());
+  // json->SetInteger(kEndTimeKey, -1);
+  json->SetInteger(kFileSizeKey, item->total_bytes());
   return json;
 }
 }  // anonymous namespace
 
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile)
   : profile_(profile),
     manager_(
         profile ?
         DownloadServiceFactory::GetForProfile(profile)->GetDownloadManager() :
@@ skipping 63 matching lines @@
   ListValue args;
   args.Append(arg);
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name,
       json_args,
       profile_,
       GURL());
 }