SSL Fix: Step 3....

chrome/common/resource_dispatcher.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/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 29 matching lines @@
 
 namespace webkit_glue {
 
 class IPCResourceLoaderBridge : public ResourceLoaderBridge {
  public:
   IPCResourceLoaderBridge(ResourceDispatcher* dispatcher,
                           const std::string& method,
                           const GURL& url,
                           const GURL& policy_url,
                           const GURL& referrer,
+                          const std::string& frame_origin,
+                          const std::string& main_frame_origin,
                           const std::string& headers,
                           int load_flags,
                           int origin_pid,
                           ResourceType::Type resource_type,
-                          bool mixed_content,
                           uint32 request_context,
                           int route_id);
   virtual ~IPCResourceLoaderBridge();
 
   // ResourceLoaderBridge
   virtual void AppendDataToUpload(const char* data, int data_len);
   virtual void AppendFileRangeToUpload(const std::wstring& path,
                                        uint64 offset, uint64 length);
   virtual bool Start(Peer* peer);
   virtual void Cancel();
@@ skipping 26 matching lines @@
   std::string url_;
 #endif
 };
 
 IPCResourceLoaderBridge::IPCResourceLoaderBridge(
     ResourceDispatcher* dispatcher,
     const std::string& method,
     const GURL& url,
     const GURL& policy_url,
     const GURL& referrer,
+    const std::string& frame_origin,
+    const std::string& main_frame_origin,
     const std::string& headers,
     int load_flags,
     int origin_pid,
     ResourceType::Type resource_type,
-    bool mixed_content,
     uint32 request_context,
     int route_id)
     : peer_(NULL),
       dispatcher_(dispatcher),
       request_id_(-1),
       route_id_(route_id) {
   DCHECK(dispatcher_) << "no resource dispatcher";
   request_.method = method;
   request_.url = url;
   request_.policy_url = policy_url;
   request_.referrer = referrer;
+  request_.frame_origin = frame_origin;
+  request_.main_frame_origin = main_frame_origin;
   request_.headers = headers;
   request_.load_flags = load_flags;
   request_.origin_pid = origin_pid;
   request_.resource_type = resource_type;
-  request_.mixed_content = mixed_content;
   request_.request_context = request_context;
 
 #ifdef LOG_RESOURCE_REQUESTS
   url_ = url.possibly_invalid_spec();
 #endif
 }
 
 IPCResourceLoaderBridge::~IPCResourceLoaderBridge() {
   // we remove our hook for the resource dispatcher only when going away, since
   // it doesn't keep track of whether we've force terminated the request
@@ skipping 29 matching lines @@
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     return false;
   }
 
   RESOURCE_LOG("Starting request for " << url_);
 
   peer_ = peer;
 
   // generate the request ID, and append it to the message
-  request_id_ = dispatcher_->AddPendingRequest(peer_, request_.resource_type,
-                                               request_.mixed_content);
+  request_id_ = dispatcher_->AddPendingRequest(peer_, request_.resource_type);
 
   return dispatcher_->message_sender()->Send(
       new ViewHostMsg_RequestResource(route_id_, request_id_, request_));
 }
 
 void IPCResourceLoaderBridge::Cancel() {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to cancel an unstarted request";
     return;
   }
@@ skipping 249 matching lines @@
   // The request ID will be removed from our pending list in the destructor.
   // Normally, dispatching this message causes the reference-counted request to
   // die immediately.
   peer->OnCompletedRequest(status, security_info);
 
   webkit_glue::NotifyCacheStats();
 }
 
 int ResourceDispatcher::AddPendingRequest(
     webkit_glue::ResourceLoaderBridge::Peer* callback,
-    ResourceType::Type resource_type,
-    bool mixed_content) {
+    ResourceType::Type resource_type) {
   // Compute a unique request_id for this renderer process.
   int id = MakeRequestID();
-  pending_requests_[id] = PendingRequestInfo(callback, resource_type,
-                                             mixed_content);
+  pending_requests_[id] = PendingRequestInfo(callback, resource_type);
   return id;
 }
 
 bool ResourceDispatcher::RemovePendingRequest(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
   pending_requests_.erase(it);
   return true;
 }
@@ skipping 43 matching lines @@
     DispatchMessage(*m);
     delete m;
   }
 }
 
 webkit_glue::ResourceLoaderBridge* ResourceDispatcher::CreateBridge(
     const std::string& method,
     const GURL& url,
     const GURL& policy_url,
     const GURL& referrer,
+    const std::string& frame_origin,
+    const std::string& main_frame_origin,
     const std::string& headers,
     int flags,
     int origin_pid,
     ResourceType::Type resource_type,
-    bool mixed_content,
     uint32 request_context,
     int route_id) {
   return new webkit_glue::IPCResourceLoaderBridge(this, method, url, policy_url,
-                                                  referrer, headers, flags,
-                                                  origin_pid, resource_type,
-                                                  mixed_content,
-                                                  request_context,
-                                                  route_id);
+                                                  referrer, frame_origin,
+                                                  main_frame_origin, headers,
+                                                  flags, origin_pid,
+                                                  resource_type,
+                                                  request_context, route_id);
 }
 
 
 bool ResourceDispatcher::IsResourceMessage(const IPC::Message& message) const {
   switch (message.type()) {
     case ViewMsg_Resource_DownloadProgress::ID:
     case ViewMsg_Resource_UploadProgress::ID:
     case ViewMsg_Resource_ReceivedResponse::ID:
     case ViewMsg_Resource_ReceivedRedirect::ID:
     case ViewMsg_Resource_DataReceived::ID:
     case ViewMsg_Resource_RequestComplete::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }