Move chrome.downloads out of experimental to dev

chrome/browser/extensions/api/downloads/downloads_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/download/download_extension_api.h"
+#include "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/download/download_file_icon_extractor.h"
 #include "chrome/browser/download/download_query.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_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 "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_save_info.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
@@ skipping 35 matching lines @@
 const char kDangerSafe[] = "safe";
 const char kDangerUncommon[] = "uncommon";
 const char kDangerUrl[] = "url";
 const char kEndTimeKey[] = "endTime";
 const char kErrorKey[] = "error";
 const char kFileSizeKey[] = "fileSize";
 const char kFilenameKey[] = "filename";
 const char kFilenameRegexKey[] = "filenameRegex";
 const char kHeaderNameKey[] = "name";
 const char kHeaderValueKey[] = "value";
-const char kHeaderBinaryValueKey[] = "binaryValue";
 const char kHeadersKey[] = "headers";
 const char kIdKey[] = "id";
 const char kIncognito[] = "incognito";
 const char kLimitKey[] = "limit";
 const char kMethodKey[] = "method";
 const char kMimeKey[] = "mime";
 const char kOrderByKey[] = "orderBy";
 const char kPausedKey[] = "paused";
 const char kQueryKey[] = "query";
 const char kSaveAsKey[] = "saveAs";
 const char kSizeKey[] = "size";
 const char kStartTimeKey[] = "startTime";
 const char kStartedAfterKey[] = "startedAfter";
 const char kStartedBeforeKey[] = "startedBefore";
 const char kStateComplete[] = "complete";
 const char kStateInProgress[] = "in_progress";
 const char kStateInterrupted[] = "interrupted";
 const char kStateKey[] = "state";
 const char kTotalBytesKey[] = "totalBytes";
 const char kTotalBytesGreaterKey[] = "totalBytesGreater";
 const char kTotalBytesLessKey[] = "totalBytesLess";
 const char kUrlKey[] = "url";
 const char kUrlRegexKey[] = "urlRegex";
 
 // Note: Any change to the danger type strings, should be accompanied by a
-// corresponding change to {experimental.}downloads.json.
+// corresponding change to downloads.json.
 const char* kDangerStrings[] = {
   kDangerSafe,
   kDangerFile,
   kDangerUrl,
   kDangerContent,
   kDangerSafe,
   kDangerUncommon,
 };
 COMPILE_ASSERT(arraysize(kDangerStrings) == content::DOWNLOAD_DANGER_TYPE_MAX,
                download_danger_type_enum_changed);
 
 // Note: Any change to the state strings, should be accompanied by a
-// corresponding change to {experimental.}downloads.json.
+// corresponding change to downloads.json.
 const char* kStateStrings[] = {
   kStateInProgress,
   kStateComplete,
   kStateInterrupted,
   NULL,
   kStateInterrupted,
 };
 COMPILE_ASSERT(arraysize(kStateStrings) == DownloadItem::MAX_DOWNLOAD_STATE,
                download_item_state_enum_changed);
 
@@ skipping 312 matching lines @@
   }
 
   if (iodata_->extra_headers != NULL) {
     for (size_t index = 0; index < iodata_->extra_headers->GetSize(); ++index) {
       base::DictionaryValue* header = NULL;
       std::string name;
       EXTENSION_FUNCTION_VALIDATE(iodata_->extra_headers->GetDictionary(
             index, &header));
       EXTENSION_FUNCTION_VALIDATE(header->GetString(
             kHeaderNameKey, &name));
-      if (header->HasKey(kHeaderBinaryValueKey)) {
-        base::ListValue* binary_value = NULL;
-        EXTENSION_FUNCTION_VALIDATE(header->GetList(
-              kHeaderBinaryValueKey, &binary_value));
-        for (size_t char_i = 0; char_i < binary_value->GetSize(); ++char_i) {
-          int char_value = 0;
-          EXTENSION_FUNCTION_VALIDATE(binary_value->GetInteger(
-                char_i, &char_value));
-        }
-      } else if (header->HasKey(kHeaderValueKey)) {
-        std::string value;
-        EXTENSION_FUNCTION_VALIDATE(header->GetString(
-              kHeaderValueKey, &value));
-      }
       if (!net::HttpUtil::IsSafeHeader(name)) {
         error_ = download_extension_errors::kGenericError;
         return false;
       }
     }
   }
   iodata_->rdh = content::ResourceDispatcherHost::Get();
   iodata_->resource_context = profile()->GetResourceContext();
   iodata_->render_process_host_id = render_view_host()->GetProcess()->GetID();
   iodata_->render_view_host_routing_id = render_view_host()->GetRoutingID();
@@ skipping 20 matching lines @@
   save_info.prompt_for_save_location = iodata_->save_as;
 
   scoped_ptr<net::URLRequest> request(new net::URLRequest(iodata_->url, NULL));
   request->set_method(iodata_->method);
   if (iodata_->extra_headers != NULL) {
     for (size_t index = 0; index < iodata_->extra_headers->GetSize(); ++index) {
       base::DictionaryValue* header = NULL;
       std::string name, value;
       CHECK(iodata_->extra_headers->GetDictionary(index, &header));
       CHECK(header->GetString(kHeaderNameKey, &name));
-      if (header->HasKey(kHeaderBinaryValueKey)) {
-        base::ListValue* binary_value = NULL;
-        CHECK(header->GetList(kHeaderBinaryValueKey, &binary_value));
-        for (size_t char_i = 0; char_i < binary_value->GetSize(); ++char_i) {
-          int char_value = 0;
-          CHECK(binary_value->GetInteger(char_i, &char_value));
-          if ((0 <= char_value) &&
-              (char_value <= 0xff)) {
-            value.push_back(char_value);
-          }
-        }
-      } else if (header->HasKey(kHeaderValueKey)) {
-        CHECK(header->GetString(kHeaderValueKey, &value));
-      }
+      CHECK(header->GetString(kHeaderValueKey, &value));
       request->SetExtraRequestHeaderByName(name, value, false/*overwrite*/);
     }
   }
   if (!iodata_->post_body.empty()) {
     request->AppendBytesToUpload(iodata_->post_body.data(),
                                  iodata_->post_body.size());
   }
 
   // Prevent login prompts for 401/407 responses.
   request->set_load_flags(request->load_flags() |
@@ skipping 343 matching lines @@
 
 bool DownloadsGetFileIconFunction::ParseArgs() {
   int dl_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &dl_id));
 
   base::DictionaryValue* options = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
   if (options->HasKey(kSizeKey)) {
     EXTENSION_FUNCTION_VALIDATE(options->GetInteger(kSizeKey, &icon_size_));
     // We only support 16px and 32px icons. This is enforced in
-    // experimental.downloads.json.
+    // downloads.json.
     DCHECK(icon_size_ == 16 || icon_size_ == 32);
   }
 
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(profile(), include_incognito(), &manager, &incognito_manager);
   DownloadItem* download_item = manager->GetDownloadItem(dl_id);
   if (!download_item && incognito_manager)
     download_item = incognito_manager->GetDownloadItem(dl_id);
   if (!download_item) {
@@ skipping 24 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (url.empty())
     error_ = download_extension_errors::kIconNotFoundError;
   else
     result_.reset(base::Value::CreateStringValue(url));
   SendResponse(error_.empty());
 }
 
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(Profile* profile)
   : profile_(profile),
-    manager_(NULL),
-    delete_item_jsons_(&item_jsons_),
-    delete_on_changed_stats_(&on_changed_stats_) {
+    manager_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
   // Register a callback with the DownloadService for this profile to be called
   // when it creates the DownloadManager, or now if the manager already exists.
   DownloadServiceFactory::GetForProfile(profile)->OnManagerCreated(base::Bind(
       &ExtensionDownloadsEventRouter::Init, base::Unretained(this)));
 }
 
 // The only public methods on this class are ModelChanged() and
 // ManagerGoingDown(), and they are only called by DownloadManager, so
 // there's no way for any methods on this class to be called before
 // DownloadService calls Init() via the OnManagerCreated Callback above.
 void ExtensionDownloadsEventRouter::Init(DownloadManager* manager) {
   DCHECK(manager_ == NULL);
   manager_ = manager;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   manager_->AddObserver(this);
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
   if (manager_ != NULL)
     manager_->RemoveObserver(this);
   for (ItemMap::const_iterator iter = downloads_.begin();
        iter != downloads_.end(); ++iter) {
     if (iter->second != NULL)
       iter->second->RemoveObserver(this);
   }
+  STLDeleteValues(&item_jsons_);
+  STLDeleteValues(&on_changed_stats_);
 }
 
 ExtensionDownloadsEventRouter::OnChangedStat::OnChangedStat()
   : fires(0),
     total(0) {
 }
 
 ExtensionDownloadsEventRouter::OnChangedStat::~OnChangedStat() {
   if (total > 0)
     UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged", (fires * 100 / total));
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(DownloadItem* item) {
+  if (!profile_)
+    return;
   int download_id = item->GetId();
   if (item->GetState() == DownloadItem::REMOVING) {
     // The REMOVING state indicates that this item is being erased.
     // Let's unregister as an observer so that we don't see any more updates
     // from it, dispatch the onErased event, and remove its json and is
     // OnChangedStat from our maps.
     downloads_.erase(download_id);
     item->RemoveObserver(this);
     DispatchEvent(extension_event_names::kOnDownloadErased,
                   base::Value::CreateIntegerValue(download_id));
@@ skipping 16 matching lines @@
   // set the differences in the |delta| object and remember that something
   // significant changed.
   for (base::DictionaryValue::Iterator iter(*new_json.get());
        iter.HasNext(); iter.Advance()) {
     new_fields.insert(iter.key());
     if (iter.key() != kBytesReceivedKey) {
       base::Value* old_value = NULL;
       if (!old_json->HasKey(iter.key()) ||
           (old_json->Get(iter.key(), &old_value) &&
            !iter.value().Equals(old_value))) {
-        delta->Set(iter.key() + ".new", iter.value().DeepCopy());
+        delta->Set(iter.key() + ".current", iter.value().DeepCopy());
         if (old_value)
-          delta->Set(iter.key() + ".old", old_value->DeepCopy());
+          delta->Set(iter.key() + ".previous", old_value->DeepCopy());
         changed = true;
       }
     }
   }
 
   // If a field was in the previous json but is not in the new json, set the
   // difference in |delta|.
   for (base::DictionaryValue::Iterator iter(*old_json);
        iter.HasNext(); iter.Advance()) {
     if (new_fields.find(iter.key()) == new_fields.end()) {
-      delta->Set(iter.key() + ".old", iter.value().DeepCopy());
+      delta->Set(iter.key() + ".previous", iter.value().DeepCopy());
       changed = true;
     }
   }
 
   // Update the OnChangedStat and dispatch the event if something significant
   // changed. Replace the stored json with the new json.
   ++(on_changed_stats_[download_id]->total);
   if (changed) {
     DispatchEvent(extension_event_names::kOnDownloadChanged, delta.release());
     ++(on_changed_stats_[download_id]->fires);
   }
   item_jsons_[download_id]->Swap(new_json.get());
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadOpened(DownloadItem* item) {
 }
 
 void ExtensionDownloadsEventRouter::ModelChanged(DownloadManager* manager) {
+  if (!profile_)
+    return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(manager_ == manager);
   typedef std::set<int> DownloadIdSet;
 
   // Get all the download items.
   DownloadManager::DownloadVector current_vec;
   manager_->SearchDownloads(string16(), &current_vec);
 
   // Populate set<>s of download item identifiers so that we can find
   // differences between the old and the new set of download items.
@@ skipping 36 matching lines @@
   downloads_.swap(current_map);
 
   // Dispatching onErased is handled in OnDownloadUpdated when an item
   // transitions to the REMOVING state.
 }
 
 void ExtensionDownloadsEventRouter::ManagerGoingDown(
     DownloadManager* manager) {
   manager_->RemoveObserver(this);
   manager_ = NULL;
+  profile_ = NULL;
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const char* event_name, base::Value* arg) {
-  ListValue args;
+  if (!profile_ || !profile_->GetExtensionEventRouter())
+    return;
+  base::ListValue args;
   args.Append(arg);
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name,
       json_args,
       profile_,
       GURL());
 }