fix a problem that android cannot download files with basic authentication

chrome/browser/download/download_request_limiter.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_request_limiter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_service.h"
@@ skipping 210 matching lines @@
     DownloadRequestLimiter::GetDownloadStatus(WebContents* web_contents) {
   TabDownloadState* state = GetDownloadState(web_contents, NULL, false);
   return state ? state->download_status() : ALLOW_ONE_DOWNLOAD;
 }
 
 void DownloadRequestLimiter::CanDownloadOnIOThread(
     int render_process_host_id,
     int render_view_id,
     int request_id,
     const std::string& request_method,
+    bool has_auth,
     const Callback& callback) {
   // This is invoked on the IO thread. Schedule the task to run on the UI
   // thread so that we can query UI state.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadRequestLimiter::CanDownload, this,
                  render_process_host_id, render_view_id, request_id,
-                 request_method, callback));
+                 request_method, has_auth, callback));
 }
 
 DownloadRequestLimiter::TabDownloadState*
 DownloadRequestLimiter::GetDownloadState(
     WebContents* web_contents,
     WebContents* originating_web_contents,
     bool create) {
   DCHECK(web_contents);
   StateMap::iterator i = state_map_.find(web_contents);
   if (i != state_map_.end())
     return i->second;
 
   if (!create)
     return NULL;
 
   TabDownloadState* state =
       new TabDownloadState(this, web_contents, originating_web_contents);
   state_map_[web_contents] = state;
   return state;
 }
 
 void DownloadRequestLimiter::CanDownload(int render_process_host_id,
                                          int render_view_id,
                                          int request_id,
                                          const std::string& request_method,
+                                         bool has_auth,
                                          const Callback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents) {
     // The WebContents was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
 
   CanDownloadImpl(
       originating_contents,
       request_id,
       request_method,
+      has_auth,
       callback);
 }
 
 void DownloadRequestLimiter::CanDownloadImpl(WebContents* originating_contents,
                                              int request_id,
                                              const std::string& request_method,
+                                             bool has_auth,
                                              const Callback& callback) {
   DCHECK(originating_contents);
 
   // FYI: Chrome Frame overrides CanDownload in ExternalTabContainer in order
   // to cancel the download operation in chrome and let the host browser
   // take care of it.
   if (originating_contents->GetDelegate() &&
       !originating_contents->GetDelegate()->CanDownload(
           originating_contents->GetRenderViewHost(),
           request_id,
-          request_method)) {
+          request_method,
+          has_auth)) {
     ScheduleNotification(callback, false);
     return;
   }
 
   // If the tab requesting the download is a constrained popup that is not
   // shown, treat the request as if it came from the parent.
   WebContents* effective_contents = originating_contents;
   BlockedContentTabHelper* blocked_content_tab_helper =
       BlockedContentTabHelper::FromWebContents(originating_contents);
   if (blocked_content_tab_helper &&
@@ skipping 36 matching lines @@
                                                   bool allow) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(callback, allow));
 }
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state) {
   DCHECK(ContainsKey(state_map_, state->web_contents()));
   state_map_.erase(state->web_contents());
   delete state;
 }