Get rid of stashing a frame pointer with ResourceRequest and just store the r...

webkit/glue/resource_handle_impl.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.
 //
 // This file replaces WebCore/platform/network/win/ResourceHandleWin.cpp with a
 // platform-neutral implementation that simply defers almost entirely to
 // ResouceLoaderBridge.
 //
 // This uses the same ResourceHandle.h header file that the rest of WebKit
 // uses, allowing us to avoid complicated changes. Our specific things are
@@ skipping 10 matching lines @@
 // as long as it doesn't care about canceling the request. Although this is
 // dumb, we support it. We use pending_ to indicate this extra AddRef, which
 // is done in start() and released in OnCompletedRequest.
 
 #include "config.h"
 
 #include "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "CString.h"
-#include "Console.h"
 #include "DocLoader.h"
-#include "DOMWindow.h"
 #include "FormData.h"
 #include "FrameLoader.h"
 #include "Page.h"
 #include "ResourceError.h"
 #include "ResourceHandle.h"
 #include "ResourceHandleClient.h"
 #include "ResourceRequest.h"
 #include "ResourceResponse.h"
 MSVC_POP_WARNING();
 
 #undef LOG
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/time.h"
 #include "base/string_util.h"
 #include "base/string_tokenizer.h"
 #include "webkit/glue/feed_preview.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/multipart_response_delegate.h"
 #include "webkit/glue/resource_loader_bridge.h"
-#include "webkit/glue/webframe_impl.h"
 #include "net/base/data_url.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using base::Time;
 using base::TimeDelta;
 using net::HttpResponseHeaders;
@@ skipping 239 matching lines @@
 
   // We are done using the object. ResourceHandle and ResourceHandleInternal
   // might be destroyed now.
   job_->deref();
 }
 
 bool ResourceHandleInternal::Start(
     ResourceLoaderBridge::SyncLoadResponse* sync_load_response) {
   DCHECK(!bridge_.get());
 
-  // The WebFrame is the Frame's FrameWinClient
-  WebFrameImpl* webframe =
-      request_.frame() ? WebFrameImpl::FromFrame(request_.frame()) : NULL;
-
   CString method = request_.httpMethod().latin1();
   GURL referrer(webkit_glue::StringToStdString(request_.httpReferrer()));
 
   // Compute the URL of the load.
   GURL url = webkit_glue::KURLToGURL(request_.url());
   if (url.SchemeIs("feed:")) {
     // Feed URLs are special, they actually mean "http".
     url_canon::Replacements<char> replacements;
     replacements.SetScheme("http", url_parse::Component(0, 4));
     url = url.ReplaceComponents(replacements);
 
     // Replace our client with a client that understands previewing feeds
     // and forwards the feeds along to the original client.
     feed_client_proxy_.reset(new FeedClientProxy(client_));
     client_ = feed_client_proxy_.get();
   }
 
-  // Inherit the policy URL from the request's frame. However, if the request
-  // is for a main frame, the current document's policyBaseURL is the old
-  // document, so we leave policyURL empty to indicate that the request is a
-  // first-party request.
-  GURL policy_url;
-  if (request_.targetType() != ResourceRequest::TargetIsMainFrame &&
-      request_.frame() && request_.frame()->document()) {
-    policy_url = GURL(webkit_glue::StringToStdString(
-        request_.frame()->document()->policyBaseURL()));
-  }
-
   switch (request_.cachePolicy()) {
     case ReloadIgnoringCacheData:
       // Required by LayoutTests/http/tests/misc/refresh-headers.php
       load_flags_ |= net::LOAD_VALIDATE_CACHE;
       break;
     case ReturnCacheDataElseLoad:
       load_flags_ |= net::LOAD_PREFERRING_CACHE;
       break;
     case ReturnCacheDataDontLoad:
       load_flags_ |= net::LOAD_ONLY_FROM_CACHE;
@@ skipping 30 matching lines @@
     // Skip over "Cache-Control: max-age=0" header if the corresponding
     // load flag is already specified. FrameLoader sets both the flag and
     // the extra header -- the extra header is redundant since our network
     // implementation will add the necessary headers based on load flags.
     // See http://code.google.com/p/chromium/issues/detail?id=3434.
     if ((load_flags_ & net::LOAD_VALIDATE_CACHE) &&
         equalIgnoringCase((*it).first, "cache-control") &&
         (*it).second == "max-age=0")
       continue;
 
-    // WinInet dies if blank headers are set.  TODO(darin): Is this still an
-    // issue now that we are using WinHTTP?
-    if ((*it).first.isEmpty()) {
-      webframe->frame()->domWindow()->console()->addMessage(
-        JSMessageSource,
-        ErrorMessageLevel,
-        "Refused to set blank header",
-        1,
-        String());
-      continue;
-    }
     if (!headerBuf.isEmpty())
       headerBuf.append(crlf);
     headerBuf.append((*it).first + sep + (*it).second);
   }
 
   // TODO(jcampan): in the non out-of-process plugin case the request does not
-  // have a origin_pid. Find a better place to set this.
-  int origin_pid = request_.originPid();
-  if (origin_pid == 0)
-    origin_pid = base::GetCurrentProcId();
+  // have a requestor_pid. Find a better place to set this.
+  int requestor_pid = request_.requestorProcessID();
+  if (requestor_pid == 0)
+    requestor_pid = base::GetCurrentProcId();
 
   bool mixed_content =
       webkit_glue::KURLToGURL(request_.mainDocumentURL()).SchemeIsSecure() &&
       !url.SchemeIsSecure();
 
   if (url.SchemeIs("data")) {
     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       std::string data;
       GetInfoFromDataUrl(sync_load_response->url, sync_load_response,
                          &sync_load_response->data,
                          &sync_load_response->status);
     } else {
       pending_ = true;
       job_->ref();  // to be released when we get a OnCompletedRequest.
       job_->ref();  // to be released when HandleDataUrl is completed.
       MessageLoop::current()->PostTask(FROM_HERE,
           data_url_factory_.NewRunnableMethod(
               &ResourceHandleInternal::HandleDataUrl));
     }
     return true;
   }
 
   // TODO(darin): is latin1 really correct here?  It is if the strings are
   // already ASCII (i.e., if they are already escaped properly).
   // TODO(brettw) this should take parameter encoding into account when
   // creating the GURLs.
   bridge_.reset(ResourceLoaderBridge::Create(
-      webframe,
       webkit_glue::CStringToStdString(method),
       url,
-      policy_url,
+      webkit_glue::KURLToGURL(request_.policyURL()),
       referrer,
       webkit_glue::CStringToStdString(headerBuf.latin1()),
       load_flags_,
-      origin_pid,
+      requestor_pid,
       FromTargetType(request_.targetType()),
-      mixed_content));
+      mixed_content,
+      request_.requestorID()));
   if (!bridge_.get())
     return false;
 
   if (request_.httpBody()) {
     // GET and HEAD requests shouldn't have http bodies.
     DCHECK(method != "GET" && method != "HEAD");
     const Vector<FormDataElement>& elements = request_.httpBody()->elements();
     size_t n = elements.size();
     for (size_t i = 0; i < n; ++i) {
       const FormDataElement& e = elements[static_cast<unsigned>(i)];
@@ skipping 309 matching lines @@
   // if the request cannot be serviced from cache.  We force the 'DontLoad'
   // cache policy at this point to ensure that we never hit the network for
   // this request.
   //
   DCHECK(request.httpMethod() == "POST");
   request.setCachePolicy(ReturnCacheDataDontLoad);
   return true;
 }
 
 }  // namespace WebCore