test http auth-basic handling and implement headers.binaryValue for downloads.download()

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 26 matching lines @@
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "content/browser/download/download_state_info.h"
 #include "content/browser/download/download_types.h"
 #include "content/browser/download/interrupt_reasons.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/render_process_host.h"
+#include "net/base/load_flags.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 
 namespace download_extension_errors {
 
@@ skipping 25 matching lines @@
 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 kFilenameRegexKey[] = "filenameRegex";
 const char kHeaderNameKey[] = "name";
 const char kHeaderValueKey[] = "value";
+const char kHeaderBinaryValueKey[] = "binaryValue";
 const char kHeadersKey[] = "headers";
 const char kIdKey[] = "id";
 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";
@@ skipping 295 matching lines @@
   }
 
   if (options->HasKey(kBodyKey)) {
     EXTENSION_FUNCTION_VALIDATE(options->GetString(
         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;
+      std::string name;
       EXTENSION_FUNCTION_VALIDATE(iodata_->extra_headers->GetDictionary(
             index, &header));
       EXTENSION_FUNCTION_VALIDATE(header->GetString(
             kHeaderNameKey, &name));
-      EXTENSION_FUNCTION_VALIDATE(header->GetString(
-            kHeaderValueKey, &value));
+      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 = ResourceDispatcherHost::Get();
   iodata_->resource_context = profile()->GetResourceContext();
   iodata_->render_process_host_id = render_view_host()->process()->GetID();
   iodata_->render_view_host_routing_id = render_view_host()->routing_id();
@@ skipping 20 matching lines @@
   save_info.prompt_for_save_location = iodata_->save_as;
 
   scoped_ptr<net::URLRequest> request(
       new net::URLRequest(iodata_->url, iodata_->rdh));
   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("name", &name));
-      CHECK(header->GetString("value", &value));
+      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));
+      }
       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() |
+                          net::LOAD_DO_NOT_PROMPT_FOR_LOGIN);
+
   net::Error error = iodata_->rdh->BeginDownload(
       request.Pass(),
       false,  // prefer_cache
       save_info,
       base::Bind(&DownloadsDownloadFunction::OnStarted, this),
       iodata_->render_process_host_id,
       iodata_->render_view_host_routing_id,
       iodata_->resource_context);
   iodata_.reset();
 
@@ skipping 561 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());
 }