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

chrome/browser/renderer_host/resource_dispatcher_host.h

 // 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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
 // dispatches them to URLRequests. It then fowards the messages from the
 // URLRequests back to the correct process for handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
@@ skipping 42 matching lines @@
 
   // Holds the data we would like to associate with each request
   class ExtraRequestInfo : public URLRequest::UserData {
    friend class ResourceDispatcherHost;
    public:
     ExtraRequestInfo(ResourceHandler* handler,
                      ChildProcessInfo::ProcessType process_type,
                      int process_id,
                      int route_id,
                      int request_id,
-                     bool mixed_content,
+                     std::string frame_origin,
+                     std::string main_frame_origin,
                      ResourceType::Type resource_type,
                      uint64 upload_size)
         : resource_handler(handler),
           cross_site_handler(NULL),
           login_handler(NULL),
           process_type(process_type),
           process_id(process_id),
           route_id(route_id),
           request_id(request_id),
           pending_data_count(0),
           is_download(false),
           pause_count(0),
-          mixed_content(mixed_content),
+          frame_origin(frame_origin),
+          main_frame_origin(main_frame_origin),
           resource_type(resource_type),
           filter_policy(FilterPolicy::DONT_FILTER),
           last_load_state(net::LOAD_STATE_IDLE),
           upload_size(upload_size),
           last_upload_position(0),
           waiting_for_upload_progress_ack(false),
           memory_cost(0),
           is_paused(false),
           has_started_reading(false),
           paused_read_bytes(0) {
@@ skipping 21 matching lines @@
 
     // Downloads allowed only as a top level request.
     bool allow_download;
 
     // Whether this is a download.
     bool is_download;
 
     // The number of clients that have called pause on this request.
     int pause_count;
 
-    // Whether this request is served over HTTP and the main page was served
-    // over HTTPS.
-    bool mixed_content;
+    std::string frame_origin;
+
+    std::string main_frame_origin;
 
     ResourceType::Type resource_type;
 
     // Whether the content for this request should be filtered (on the renderer
     // side) to make it more secure: images are stamped, frame content is
     // replaced with an error message and all other resources are entirely
     // filtered out.
     FilterPolicy::Type filter_policy;
 
     net::LoadState last_load_state;
@@ skipping 233 matching lines @@
   FRIEND_TEST(ResourceDispatcherHostTest,
               IncrementOutstandingRequestsMemoryCost);
   FRIEND_TEST(ResourceDispatcherHostTest,
               CalculateApproximateMemoryCost);
 
   class ShutdownTask;
 
   friend class ShutdownTask;
 
   struct BlockedRequest {
-    BlockedRequest(URLRequest* url_request, bool mixed_content)
-        : url_request(url_request),
-          mixed_content(mixed_content) {
+    BlockedRequest(URLRequest* url_request)
+        : url_request(url_request) {
     }
     URLRequest* url_request;
-    bool mixed_content;
   };
 
   // A shutdown helper that runs on the IO thread.
   void OnShutdown();
 
   // Returns true if the request is paused.
   bool PauseRequestIfNeeded(ExtraRequestInfo* info);
 
   // Resumes the given request by calling OnResponseStarted or OnReadCompleted.
   void ResumeRequest(const GlobalRequestID& request_id);
@@ skipping 14 matching lines @@
 
   // Cancels the given request if it still exists. We ignore cancels from the
   // renderer in the event of a download. If |allow_delete| is true and no IO
   // is pending, the request is removed and deleted.
   void CancelRequest(int process_id,
                      int request_id,
                      bool from_renderer,
                      bool allow_delete);
 
   // Helper function for regular and download requests.
-  void BeginRequestInternal(URLRequest* request, bool mixed_content);
+  void BeginRequestInternal(URLRequest* request);
 
   // Updates the "cost" of outstanding requests for |process_id|.
   // The "cost" approximates how many bytes are consumed by all the in-memory
   // data structures supporting this request (URLRequest object,
   // HttpNetworkTransaction, etc...).
   // The value of |cost| is added to the running total, and the resulting
   // sum is returned.
   int IncrementOutstandingRequestsMemoryCost(int cost,
                                              int process_id);
 
@@ skipping 100 matching lines @@
   // individual requests is given by CalculateApproximateMemoryCost).
   // The total number of outstanding requests is roughly:
   //   (max_outstanding_requests_cost_per_process_ /
   //       kAvgBytesPerOutstandingRequest)
   int max_outstanding_requests_cost_per_process_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_