Fix our handling of mixed SSL / non-SSL content....

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2006-2008 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 305 matching lines @@
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
   // Make extra info and read footer (contains request ID).
   ExtraRequestInfo* extra_info =
       new ExtraRequestInfo(handler,
                            process_type,
                            process_id,
                            route_id,
                            request_id,
-                           request_data.mixed_content,
+                           request_data.frame_origin,
+                           request_data.main_frame_origin,
                            request_data.resource_type,
                            upload_size);
   extra_info->allow_download =
       ResourceType::IsFrame(request_data.resource_type);
   request->set_user_data(extra_info);  // takes pointer ownership
 
-  BeginRequestInternal(request, request_data.mixed_content);
+  BeginRequestInternal(request);
 }
 
 // We are explicitly forcing the download of 'url'.
 void ResourceDispatcherHost::BeginDownload(const GURL& url,
                                            const GURL& referrer,
                                            int process_id,
                                            int route_id,
                                            URLRequestContext* request_context) {
   if (is_shutdown_)
     return;
@@ skipping 42 matching lines @@
   request->set_method("GET");
   request->set_referrer(referrer.spec());
   request->set_context(request_context);
 
   ExtraRequestInfo* extra_info =
       new ExtraRequestInfo(handler,
                            ChildProcessInfo::RENDER_PROCESS,
                            process_id,
                            route_id,
                            request_id_,
-                           false,  // Downloads are not considered mixed-content
+                           "null",  // frame_origin
+                           "null",  // main_frame_origin
                            ResourceType::SUB_RESOURCE,
                            0 /* upload_size */ );
   extra_info->allow_download = true;
   extra_info->is_download = true;
   request->set_user_data(extra_info);  // Takes pointer ownership.
 
-  BeginRequestInternal(request, false);
+  BeginRequestInternal(request);
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(const GURL& url,
                                            const GURL& referrer,
                                            int process_id,
                                            int route_id,
                                            URLRequestContext* request_context) {
   if (is_shutdown_)
     return;
@@ skipping 25 matching lines @@
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_ONLY_FROM_CACHE);
   request->set_context(request_context);
 
   ExtraRequestInfo* extra_info =
       new ExtraRequestInfo(handler,
                            ChildProcessInfo::RENDER_PROCESS,
                            process_id,
                            route_id,
                            request_id_,
-                           false,
+                           "null",  // frame_origin
+                           "null",  // main_frame_origin
                            ResourceType::SUB_RESOURCE,
                            0 /* upload_size */);
   // Just saving some resources we need, disallow downloading.
   extra_info->allow_download = false;
   extra_info->is_download = false;
   request->set_user_data(extra_info);  // Takes pointer ownership.
 
-  BeginRequestInternal(request, false);
+  BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::CancelRequest(int process_id,
                                            int request_id,
                                            bool from_renderer) {
   CancelRequest(process_id, request_id, from_renderer, true);
 }
 
 void ResourceDispatcherHost::CancelRequest(int process_id,
                                            int request_id,
@@ skipping 450 matching lines @@
       }
     }
   }
 #endif
 
   // Note that this expression will typically be dominated by:
   // |kAvgBytesPerOutstandingRequest|.
   return kAvgBytesPerOutstandingRequest + strings_cost + upload_cost;
 }
 
-void ResourceDispatcherHost::BeginRequestInternal(URLRequest* request,
-                                                  bool mixed_content) {
+void ResourceDispatcherHost::BeginRequestInternal(URLRequest* request) {
   DCHECK(!request->is_pending());
   ExtraRequestInfo* info = ExtraInfoForRequest(request);
 
   // Add the memory estimate that starting this request will consume.
   info->memory_cost = CalculateApproximateMemoryCost(request);
   int memory_cost = IncrementOutstandingRequestsMemoryCost(
       info->memory_cost,
       info->process_id);
 
   // If enqueing/starting this request will exceed our per-process memory
   // bound, abort it right away.
   if (memory_cost > max_outstanding_requests_cost_per_process_) {
     // We call "CancelWithError()" as a way of setting the URLRequest's
     // status -- it has no effect beyond this, since the request hasn't started.
     request->SimulateError(net::ERR_INSUFFICIENT_RESOURCES);
 
     // TODO(eroman): this is kinda funky -- we insert the unstarted request into
     // |pending_requests_| simply to please OnResponseCompleted().
     GlobalRequestID global_id(info->process_id, info->request_id);
     pending_requests_[global_id] = request;
     OnResponseCompleted(request);
     return;
   }
 
   std::pair<int, int> pair_id(info->process_id, info->route_id);
   BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
   if (iter != blocked_requests_map_.end()) {
     // The request should be blocked.
-    iter->second->push_back(BlockedRequest(request, mixed_content));
+    iter->second->push_back(request);
     return;
   }
 
   GlobalRequestID global_id(info->process_id, info->request_id);
   pending_requests_[global_id] = request;
-  if (mixed_content) {
-    // We don't start the request in that case.  The SSLManager will potentially
-    // change the request (potentially to indicate its content should be
-    // filtered) and start it itself.
-    SSLManager::OnMixedContentRequest(this, request, ui_loop_);
+  if (SSLManager::ShouldDelayRequest(this, request, ui_loop_)) {
+    // The SSLManager has told us that we shouldn't start the request yet.  The
+    // SSLManager will potentially change the request (potentially to indicate
+    // its content should be filtered) and start it itself.
     return;
   }
   request->Start();
 
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_.IsRunning()) {
     update_load_states_timer_.Start(
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHost::UpdateLoadStates);
   }
@@ skipping 467 matching lines @@
   for (BlockedRequestsList::iterator req_iter = requests->begin();
        req_iter != requests->end(); ++req_iter) {
     // Remove the memory credit that we added when pushing the request onto
     // the blocked list.
     ExtraRequestInfo* info = ExtraInfoForRequest(req_iter->url_request);
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost,
                                            info->process_id);
     if (cancel_requests)
       delete req_iter->url_request;
     else
-      BeginRequestInternal(req_iter->url_request, req_iter->mixed_content);
+      BeginRequestInternal(req_iter->url_request);
   }
 
   delete requests;
 }