Replace 'ResourceRequest::TargetType' with 'ResourceRequest::RequestContext'.

Source/platform/exported/WebURLRequest.cpp

 /*
  * Copyright (C) 2009 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 206 matching lines @@
 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
 {
     m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
 }
 
 bool WebURLRequest::reportRawHeaders() const
 {
     return m_private->m_resourceRequest->reportRawHeaders();
 }
 
-WebURLRequest::TargetType WebURLRequest::targetType() const
+WebURLRequest::RequestContext WebURLRequest::requestContext() const
 {
-    // FIXME: Temporary special case until downstream chromium.org knows of the new TargetTypes.
-    TargetType targetType = static_cast<TargetType>(m_private->m_resourceRequest->targetType());
-    if (targetType == TargetIsTextTrack || targetType == TargetIsUnspecified)
-        return TargetIsSubresource;
-    return targetType;
+    return static_cast<RequestContext>(m_private->m_resourceRequest->requestContext());
 }
 
 WebReferrerPolicy WebURLRequest::referrerPolicy() const
 {
     return static_cast<WebReferrerPolicy>(m_private->m_resourceRequest->referrerPolicy());
 }
 
 void WebURLRequest::addHTTPOriginIfNeeded(const WebString& origin)
 {
     m_private->m_resourceRequest->addHTTPOriginIfNeeded(origin);
 }
 
 bool WebURLRequest::hasUserGesture() const
 {
     return m_private->m_resourceRequest->hasUserGesture();
 }
 
 void WebURLRequest::setHasUserGesture(bool hasUserGesture)
 {
     m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
 }
 
-void WebURLRequest::setTargetType(TargetType targetType)
+void WebURLRequest::setRequestContext(RequestContext requestContext)
 {
-    m_private->m_resourceRequest->setTargetType(
-        static_cast<ResourceRequest::TargetType>(targetType));
+    m_private->m_resourceRequest->setRequestContext(
+        static_cast<ResourceRequest::RequestContext>(requestContext));
 }
 
 int WebURLRequest::requestorID() const
 {
     return m_private->m_resourceRequest->requestorID();
 }
 
 void WebURLRequest::setRequestorID(int requestorID)
 {
     m_private->m_resourceRequest->setRequestorID(requestorID);
@@ skipping 74 matching lines @@
 {
     // Subclasses may call this directly so a self-assignment check is needed
     // here as well as in the public assign method.
     if (m_private == p)
         return;
     if (m_private)
         m_private->dispose();
     m_private = p;
 }
 
+WebURLRequest::RequestContext WebURLRequest::requestContextFromTargetType(WebURLRequest::TargetType targetType)
+{
+    switch (targetType) {
+    case TargetIsMainFrame:
+        return MainFrameContext;
+    case TargetIsSubframe:
+        return SubFrameContext;
+    case TargetIsSubresource:
+        return SubresourceContext;
+    case TargetIsStyleSheet:
+        return StyleContext;
+    case TargetIsScript:
+        return ScriptContext;
+    case TargetIsFontResource:
+        return FontContext;
+    case TargetIsImage:
+        return ImageContext;
+    case TargetIsObject:
+        return ObjectContext;
+    case TargetIsMedia:
+        // FIXME: Split this out.
+        return VideoContext;
+    case TargetIsWorker:
+        return WorkerContext;
+    case TargetIsSharedWorker:
+        return SharedWorkerContext;
+    case TargetIsPrefetch:
+        return PrefetchContext;
+    case TargetIsFavicon:
+        return FaviconContext;
+    case TargetIsXHR:
+        return ConnectContext;
+    case TargetIsTextTrack:
+        return TextTrackContext;
+    case TargetIsPing:
+        return PingContext;
+    case TargetIsServiceWorker:
+        return ServiceWorkerContext;
+    case TargetIsUnspecified:
+        return UnspecifiedContext;
+    }
+    ASSERT_NOT_REACHED();
+    return SubresourceContext;
+}
+
+WebURLRequest::TargetType WebURLRequest::targetTypeFromRequestContext(WebURLRequest::RequestContext requestContext)
+{
+    switch (requestContext) {
+    case UnspecifiedContext:
+        return TargetIsUnspecified;
+    case AudioContext:
+        return TargetIsMedia;
+    case ConnectContext:
+        return TargetIsXHR;
+    case DownloadContext:
+        return TargetIsSubresource;
+    case FaviconContext:
+        return TargetIsFavicon;
+    case FontContext:
+        return TargetIsFontResource;
+    case FormContext:
+        return TargetIsMainFrame;
+    case ImageContext:
+        return TargetIsImage;
+    case MainFrameContext:
+        return TargetIsMainFrame;
+    case ManifestContext:
+        return TargetIsSubresource;
+    case ObjectContext:
+        return TargetIsObject;
+    case ObjectRequestContext:
+        return TargetIsSubresource;
+    case PingContext:
+        return TargetIsPing;
+    case PopupContext:
+        return TargetIsMainFrame;
+    case PrefetchContext:
+        return TargetIsPrefetch;
+    case ScriptContext:
+        return TargetIsScript;
+    case ServiceWorkerContext:
+        return TargetIsServiceWorker;
+    case SharedWorkerContext:
+        return TargetIsSharedWorker;
+    case StyleContext:
+        return TargetIsStyleSheet;
+    case SubFrameContext:
+        return TargetIsSubframe;
+    case SubresourceContext:
+        return TargetIsSubresource;
+    case TextTrackContext:
+        return TargetIsTextTrack;
+    case VideoContext:
+        return TargetIsMedia;
+    case WorkerContext:
+        return TargetIsWorker;
+    }
+    ASSERT_NOT_REACHED();
+    return TargetIsSubresource;
+}
+
+// FIXME: Drop these two methods once embedders are updated to use RequestContexts.
+WebURLRequest::TargetType WebURLRequest::targetType() const
+{
+    // FIXME: Temporary special case until downstream chromium.org knows of the new TargetTypes.
+    TargetType targetType = WebURLRequest::targetTypeFromRequestContext(requestContext());
+    if (targetType == TargetIsTextTrack || targetType == TargetIsUnspecified)
+        return TargetIsSubresource;
+    return targetType;
+}
+
+void WebURLRequest::setTargetType(TargetType targetType)
+{
+    setRequestContext(WebURLRequest::requestContextFromTargetType(targetType));
+}
+
+
 } // namespace blink