Fix most of the downloads api in incognito profiles

chrome/browser/download/download_extension_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 <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
@@ skipping 75 matching lines @@
 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 kIncognitoNone[] = "none";
+const char kIncognitoOnly[] = "only";
 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";
@@ skipping 83 matching lines @@
   if (item->GetDangerType() != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
     json->SetBoolean(kDangerAcceptedKey,
         item->GetSafetyState() == DownloadItem::DANGEROUS_BUT_VALIDATED);
   json->SetString(kStateKey, StateString(item->GetState()));
   json->SetBoolean(kPausedKey, item->IsPaused());
   json->SetString(kMimeKey, item->GetMimeType());
   json->SetInteger(kStartTimeKey,
       (item->GetStartTime() - base::Time::UnixEpoch()).InMilliseconds());
   json->SetInteger(kBytesReceivedKey, item->GetReceivedBytes());
   json->SetInteger(kTotalBytesKey, item->GetTotalBytes());
+  json->SetBoolean(kIncognito, item->IsOtr());
   if (item->GetState() == DownloadItem::INTERRUPTED) {
     json->SetInteger(kErrorKey, static_cast<int>(item->GetLastReason()));
   } else if (item->GetState() == DownloadItem::CANCELLED) {
     json->SetInteger(kErrorKey, static_cast<int>(
         content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED));
   }
   // TODO(benjhayden): Implement endTime and fileSize.
   // json->SetInteger(kEndTimeKey, -1);
   json->SetInteger(kFileSizeKey, item->GetTotalBytes());
   return scoped_ptr<base::DictionaryValue>(json);
@@ skipping 91 matching lines @@
   sorter_types[kStartTimeKey] = DownloadQuery::SORT_START_TIME;
   sorter_types[kStateKey] = DownloadQuery::SORT_STATE;
   sorter_types[kTotalBytesKey] = DownloadQuery::SORT_TOTAL_BYTES;
   sorter_types[kUrlKey] = DownloadQuery::SORT_URL;
 }
 
 bool IsNotTemporaryDownloadFilter(const DownloadItem& item) {
   return !item.IsTemporary();
 }
 
+DownloadItem* GetItemInternal(Browser* browser, Profile* profile, int id) {
+  if ((browser != NULL) &&

[Matt Perry, 2012/05/14 22:57:11]

nit: prefer "browser" to "browser != NULL"

[benjhayden, 2012/05/15 17:16:25]

Done.

+      (browser->profile() != NULL))
+    profile = browser->profile();
+  DownloadManager* download_manager =
+      DownloadServiceFactory::GetForProfile(profile)->GetDownloadManager();
+  DownloadItem* download_item =
+      download_manager->GetActiveDownloadItem(id);
+  if (!download_item) {
+    if (profile->IsOffTheRecord()) {
+      // Try looking for the item in the original manager.
+      download_manager = DownloadServiceFactory::GetForProfile(
+          profile->GetOriginalProfile())->GetDownloadManager();
+      download_item = download_manager->GetActiveDownloadItem(id);
+    }
+    // Do not try looking for the item in the off-the-record manager if profile
+    // is on the record.
+  }
+  return download_item;
+}
+
 }  // namespace
 
 bool DownloadsFunctionInterface::RunImplImpl(
     DownloadsFunctionInterface* pimpl) {
   CHECK(pimpl);
   if (!pimpl->ParseArgs()) return false;
   UMA_HISTOGRAM_ENUMERATION(
       "Download.ApiFunctions", pimpl->function(), DOWNLOADS_FUNCTION_LAST);
   return pimpl->RunInternal();
 }
 
 SyncDownloadsFunction::SyncDownloadsFunction(
     DownloadsFunctionInterface::DownloadsFunctionName function)
   : function_(function) {
 }
 
 SyncDownloadsFunction::~SyncDownloadsFunction() {}
 
 bool SyncDownloadsFunction::RunImpl() {
   return DownloadsFunctionInterface::RunImplImpl(this);
 }
 
 DownloadsFunctionInterface::DownloadsFunctionName
 SyncDownloadsFunction::function() const {
   return function_;
 }
 
+DownloadItem* SyncDownloadsFunction::GetItem(int id) {
+  return GetItemInternal(GetCurrentBrowser(), profile(), id);
+}
+
 AsyncDownloadsFunction::AsyncDownloadsFunction(
     DownloadsFunctionInterface::DownloadsFunctionName function)
   : function_(function) {
 }
 
 AsyncDownloadsFunction::~AsyncDownloadsFunction() {}
 
 bool AsyncDownloadsFunction::RunImpl() {
   return DownloadsFunctionInterface::RunImplImpl(this);
 }
 
 DownloadsFunctionInterface::DownloadsFunctionName
 AsyncDownloadsFunction::function() const {
   return function_;
 }
 
+DownloadItem* AsyncDownloadsFunction::GetItem(int id) {
+  return GetItemInternal(GetCurrentBrowser(), profile(), id);
+}
+
 DownloadsDownloadFunction::DownloadsDownloadFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_DOWNLOAD) {
 }
 
 DownloadsDownloadFunction::~DownloadsDownloadFunction() {}
 
 DownloadsDownloadFunction::IOData::IOData()
   : save_as(false),
     extra_headers(NULL),
     method("GET"),
@@ skipping 162 matching lines @@
     result_.reset(base::Value::CreateIntegerValue(dl_id.local()));
   } else {
     error_ = net::ErrorToString(error);
   }
   SendResponse(error_.empty());
 }
 
 DownloadsSearchFunction::DownloadsSearchFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_SEARCH),
     query_(new DownloadQuery()),
+    include_on_the_record_(true),
+    include_incognito_(true),
     get_id_(0),
     has_get_id_(false) {
 }
 
 DownloadsSearchFunction::~DownloadsSearchFunction() {}
 
 bool DownloadsSearchFunction::ParseArgs() {
   static base::LazyInstance<FilterTypeMap> filter_types =
     LAZY_INSTANCE_INITIALIZER;
   if (filter_types.Get().size() == 0)
     InitFilterTypeMap(filter_types.Get());
 
   base::DictionaryValue* query_json = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &query_json));
   for (base::DictionaryValue::Iterator query_json_field(*query_json);
        query_json_field.HasNext(); query_json_field.Advance()) {
     FilterTypeMap::const_iterator filter_type =
         filter_types.Get().find(query_json_field.key());
 
     if (filter_type != filter_types.Get().end()) {
       if (!query_->AddFilter(filter_type->second, query_json_field.value())) {
         error_ = download_extension_errors::kInvalidFilterError;
         return false;
       }
     } else if (query_json_field.key() == kIdKey) {
       EXTENSION_FUNCTION_VALIDATE(query_json_field.value().GetAsInteger(
           &get_id_));
       has_get_id_ = true;
+    } else if (query_json_field.key() == kIncognito) {
+      std::string incognito;
+      EXTENSION_FUNCTION_VALIDATE(query_json_field.value().GetAsString(
+          &incognito));
+      if (incognito == kIncognitoNone) {
+        include_incognito_ = false;
+      } else if (incognito == kIncognitoOnly) {
+        include_on_the_record_ = false;
+      } else {
+        EXTENSION_FUNCTION_VALIDATE(false);
+      }
     } else if (query_json_field.key() == kOrderByKey) {
       if (!ParseOrderBy(query_json_field.value()))
         return false;
     } else if (query_json_field.key() == kDangerKey) {
       std::string danger_str;
       EXTENSION_FUNCTION_VALIDATE(query_json_field.value().GetAsString(
           &danger_str));
       content::DownloadDangerType danger_type =
           DangerEnumFromString(danger_str);
       if (danger_type == content::DOWNLOAD_DANGER_TYPE_MAX) {
@@ skipping 53 matching lines @@
       error_ = download_extension_errors::kInvalidOrderByError;
       return false;
     }
     query_->AddSorter(sorter_type->second, direction);
   }
   return true;
 }
 
 bool DownloadsSearchFunction::RunInternal() {
   DownloadQuery::DownloadVector all_items, cpp_results;
-  DownloadManager* manager = DownloadServiceFactory::GetForProfile(profile())
-    ->GetDownloadManager();
+  Profile* original_profile = NULL;

[Matt Perry, 2012/05/14 22:57:11]

you can just do profile()->GetOriginalProfile() here. It will do the right thing
in both cases.

[benjhayden, 2012/05/15 17:16:25]

Done.

+  Profile* otr_profile = NULL;
+  if (profile()->IsOffTheRecord()) {
+    otr_profile = profile();
+    original_profile = profile()->GetOriginalProfile();
+  } else {
+    original_profile = profile();
+  }
+  DownloadManager* original_manager = DownloadServiceFactory::GetForProfile(
+      original_profile)->GetDownloadManager();
+  DownloadManager* otr_manager = NULL;
+  if (otr_profile != NULL) {
+    otr_manager = DownloadServiceFactory::GetForProfile(otr_profile)
+      ->GetDownloadManager();

[Matt Perry, 2012/05/14 22:57:11]

wrap with the operator at the end of the preceding line:
  foo->
      bar()

[benjhayden, 2012/05/15 17:16:25]

Done.

+  }
   if (has_get_id_) {
-    DownloadItem* item = manager->GetDownloadItem(get_id_);
+    DownloadItem* item = original_manager->GetDownloadItem(get_id_);
+    if ((item == NULL) && (otr_manager != NULL))
+      item = otr_manager->GetDownloadItem(get_id_);
     if (item != NULL)
       all_items.push_back(item);
   } else {
-    manager->GetAllDownloads(FilePath(FILE_PATH_LITERAL("")), &all_items);
+    if (include_on_the_record_)
+      original_manager->GetAllDownloads(
+          FilePath(FILE_PATH_LITERAL("")), &all_items);
+    if (include_incognito_ && (otr_manager != NULL))
+      otr_manager->GetAllDownloads(
+          FilePath(FILE_PATH_LITERAL("")), &all_items);
   }
   query_->Search(all_items.begin(), all_items.end(), &cpp_results);
   base::ListValue* json_results = new base::ListValue();
   for (DownloadManager::DownloadVector::const_iterator it = cpp_results.begin();
        it != cpp_results.end(); ++it) {
     scoped_ptr<base::DictionaryValue> item(DownloadItemToJSON(*it));
     json_results->Append(item.release());
   }
   result_.reset(json_results);
   return true;
 }
 
 DownloadsPauseFunction::DownloadsPauseFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_PAUSE),
     download_id_(DownloadId::Invalid().local()) {
 }
 
 DownloadsPauseFunction::~DownloadsPauseFunction() {}
 
 bool DownloadsPauseFunction::ParseArgs() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &download_id_));
   return true;
 }
 
 bool DownloadsPauseFunction::RunInternal() {
-  DownloadManager* download_manager =
-      DownloadServiceFactory::GetForProfile(profile())->GetDownloadManager();
-  DownloadItem* download_item =
-      download_manager->GetActiveDownloadItem(download_id_);
-  DCHECK(!download_item || download_item->IsInProgress());
-
-  if (!download_item) {
+  DownloadItem* download_item = GetItem(download_id_);
+  if ((download_item == NULL) || !download_item->IsInProgress()) {
     // This could be due to an invalid download ID, or it could be due to the
     // download not being currently active.
     error_ = download_extension_errors::kInvalidOperationError;
   } else if (!download_item->IsPaused()) {
     // If download_item->IsPaused() already then we treat it as a success.
     download_item->TogglePause();
   }
   return error_.empty();
 }
 
 DownloadsResumeFunction::DownloadsResumeFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_RESUME),
     download_id_(DownloadId::Invalid().local()) {
 }
 
 DownloadsResumeFunction::~DownloadsResumeFunction() {}
 
 bool DownloadsResumeFunction::ParseArgs() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &download_id_));
   return true;
 }
 
 bool DownloadsResumeFunction::RunInternal() {
-  DownloadManager* download_manager =
-      DownloadServiceFactory::GetForProfile(profile())->GetDownloadManager();
-  DownloadItem* download_item =
-      download_manager->GetActiveDownloadItem(download_id_);
-  DCHECK(!download_item || download_item->IsInProgress());
-
-  if (!download_item) {
+  DownloadItem* download_item = GetItem(download_id_);
+  if (download_item == NULL) {
     // This could be due to an invalid download ID, or it could be due to the
     // download not being currently active.
     error_ = download_extension_errors::kInvalidOperationError;
   } else if (download_item->IsPaused()) {
     // If !download_item->IsPaused() already, then we treat it as a success.
     download_item->TogglePause();
   }
   return error_.empty();
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction()
   : SyncDownloadsFunction(DOWNLOADS_FUNCTION_CANCEL),
     download_id_(DownloadId::Invalid().local()) {
 }
 
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
 bool DownloadsCancelFunction::ParseArgs() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &download_id_));
   return true;
 }
 
 bool DownloadsCancelFunction::RunInternal() {
-  DownloadManager* download_manager =
-      DownloadServiceFactory::GetForProfile(profile())->GetDownloadManager();
-  DownloadItem* download_item =
-      download_manager->GetActiveDownloadItem(download_id_);
-
-  if (download_item)
+  DownloadItem* download_item = GetItem(download_id_);
+  if (download_item != NULL)
     download_item->Cancel(true);
   // |download_item| can be NULL if the download ID was invalid or if the
   // download is not currently active.  Either way, we don't consider it a
   // failure.
   return error_.empty();
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction()
   : AsyncDownloadsFunction(DOWNLOADS_FUNCTION_ERASE) {
 }
@@ skipping 329 matching lines @@
   ListValue args;
   args.Append(arg);
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name,
       json_args,
       profile_,
       GURL());
 }