Set the target type when creating the request for main resource

Source/platform/network/ResourceRequest.cpp

 /*
  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/network/ResourceRequest.h"
 
 namespace WebCore {
 
 double ResourceRequest::s_defaultTimeoutInterval = INT_MAX;
 
+
+ResourceRequest ResourceRequest::createMainResourceRequest(const KURL& url, bool isMainFrame)
+{
+    ResourceRequest request = ResourceRequest(url);
+    request.setTargetTypeForMainResource(isMainFrame);
+    return request;
+}
+
+ResourceRequest ResourceRequest::createMainResourceRequest(
+    const KURL& url, bool isMainFrame, const Referrer& referrer,
+    ResourceRequestCachePolicy cachePolicy)
+{
+    ResourceRequest request = ResourceRequest(url, referrer, cachePolicy);
+    request.setTargetTypeForMainResource(isMainFrame);
+    return request;
+}
+
 PassOwnPtr<ResourceRequest> ResourceRequest::adopt(PassOwnPtr<CrossThreadResourceRequestData> data)
 {
     OwnPtr<ResourceRequest> request = adoptPtr(new ResourceRequest());
     request->setURL(data->m_url);
     request->setCachePolicy(data->m_cachePolicy);
     request->setTimeoutInterval(data->m_timeoutInterval);
     request->setFirstPartyForCookies(data->m_firstPartyForCookies);
     request->setHTTPMethod(AtomicString(data->m_httpMethod));
     request->setPriority(data->m_priority, data->m_intraPriorityValue);
 
@@ skipping 269 matching lines @@
     DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control", AtomicString::ConstructFromLiteral));
     return cacheControlHeader;
 }
 
 static const AtomicString& pragmaHeaderString()
 {
     DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
     return pragmaHeader;
 }
 
+void ResourceRequest::setTargetTypeForMainResource(bool isMainFrame)
+{
+    m_targetType = isMainFrame ? TargetIsMainFrame : TargetIsSubframe;
+}
+
 const CacheControlHeader& ResourceRequest::cacheControlHeader() const
 {
     if (!m_cacheControlHeaderCache.parsed)
         m_cacheControlHeaderCache = parseCacheControlDirectives(m_httpHeaderFields.get(cacheControlHeaderString()), m_httpHeaderFields.get(pragmaHeaderString()));
     return m_cacheControlHeaderCache;
 }
 
 bool ResourceRequest::cacheControlContainsNoCache() const
 {
     return cacheControlHeader().containsNoCache;
@@ skipping 44 matching lines @@
 // This is used by the loader to control the number of issued parallel load requests.
 unsigned initializeMaximumHTTPConnectionCountPerHost()
 {
     // The chromium network stack already handles limiting the number of
     // parallel requests per host, so there's no need to do it here.  Therefore,
     // this is set to a high value that should never be hit in practice.
     return 10000;
 }
 
 }