Removing blink::prefix

Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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.
@@ skipping 126 matching lines @@
         m_deferredRequest = m_request;
         return;
     }
 
     if (m_state == Terminated)
         return;
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
 
-    m_loader = adoptPtr(blink::Platform::current()->createURLLoader());
+    m_loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(m_loader);
-    blink::WrappedResourceRequest wrappedRequest(m_request);
+    WrappedResourceRequest wrappedRequest(m_request);
     m_loader->loadAsynchronously(wrappedRequest, this);
 }
 
 void ResourceLoader::changeToSynchronous()
 {
     ASSERT(m_options.synchronousPolicy == RequestAsynchronously);
     ASSERT(m_loader);
     m_loader->cancel();
     m_loader.clear();
     m_request.setPriority(ResourceLoadPriorityHighest);
@@ skipping 18 matching lines @@
     if (m_loader) {
         // The implementor of the WebURLLoader assumes ownership of the
         // threaded data receiver if it signals that it got successfully
         // attached.
         WebThreadedDataReceiver* webDataReceiver = new WebThreadedDataReceiver(threadedDataReceiver);
         if (!m_loader->attachThreadedDataReceiver(webDataReceiver))
             delete webDataReceiver;
     }
 }
 
-void ResourceLoader::didDownloadData(blink::WebURLLoader*, int length, int encodedDataLength)
+void ResourceLoader::didDownloadData(WebURLLoader*, int length, int encodedDataLength)
 {
     ASSERT(m_state != Terminated);
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
     m_host->didDownloadData(m_resource, length, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64_t encodedDataLength)
 {
     // If load has been cancelled after finishing (which could happen with a
     // JavaScript that changes the window location), do nothing.
     if (m_state == Terminated)
         return;
 
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
     m_host->didFinishLoading(m_resource, finishTime, encodedDataLength);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
     if (m_loader) {
         m_host->didChangeLoadingPriority(m_resource, loadPriority, intraPriorityValue);
         ASSERT(m_state != Terminated);
-        m_loader->didChangePriority(static_cast<blink::WebURLRequest::Priority>(loadPriority), intraPriorityValue);
+        m_loader->didChangePriority(static_cast<WebURLRequest::Priority>(loadPriority), intraPriorityValue);
     }
 }
 
 void ResourceLoader::cancelIfNotFinishing()
 {
     if (m_state != Initialized)
         return;
     cancel();
 }
 
@@ skipping 33 matching lines @@
         m_notifiedLoadComplete = true;
         m_host->didFailLoading(m_resource, nonNullError);
     }
 
     if (m_state == Finishing)
         m_resource->error(Resource::LoadError);
     if (m_state != Terminated)
         releaseResources();
 }
 
-void ResourceLoader::willSendRequest(blink::WebURLLoader*, blink::WebURLRequest& passedNewRequest, const blink::WebURLResponse& passedRedirectResponse)
+void ResourceLoader::willSendRequest(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
 {
     ASSERT(m_state != Terminated);
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     ResourceRequest& newRequest(applyOptions(passedNewRequest.toMutableResourceRequest()));
 
     ASSERT(!newRequest.isNull());
     const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
     ASSERT(!redirectResponse.isNull());
     newRequest.setFollowedRedirect(true);
@@ skipping 10 matching lines @@
     if (newRequest.isNull() || m_state == Terminated)
         return;
 
     m_host->willSendRequest(m_resource->identifier(), newRequest, redirectResponse, m_options.initiatorInfo);
     ASSERT(m_state != Terminated);
     ASSERT(!newRequest.isNull());
     m_resource->updateRequest(newRequest);
     m_request = newRequest;
 }
 
-void ResourceLoader::didReceiveCachedMetadata(blink::WebURLLoader*, const char* data, int length)
+void ResourceLoader::didReceiveCachedMetadata(WebURLLoader*, const char* data, int length)
 {
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     ASSERT(m_state == Initialized);
     m_resource->setSerializedCachedMetadata(data, length);
 }
 
-void ResourceLoader::didSendData(blink::WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
+void ResourceLoader::didSendData(WebURLLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     ASSERT(m_state == Initialized);
     m_resource->didSendData(bytesSent, totalBytesToBeSent);
 }
 
 bool ResourceLoader::responseNeedsAccessControlCheck() const
 {
     // If the fetch was (potentially) CORS enabled, an access control check of the response is required.
     return m_options.corsEnabled == IsCORSEnabled;
 }
 
-void ResourceLoader::didReceiveResponse(blink::WebURLLoader*, const blink::WebURLResponse& response, WebDataConsumerHandle* rawHandle)
+void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& response, WebDataConsumerHandle* rawHandle)
 {
     ASSERT(!response.isNull());
     ASSERT(m_state == Initialized);
     // |rawHandle|'s ownership is transferred to the callee.
     OwnPtr<WebDataConsumerHandle> handle = adoptPtr(rawHandle);
 
     bool isMultipartPayload = response.isMultipartPayload();
     bool isValidStateTransition = (m_connectionState == ConnectionStateStarted || m_connectionState == ConnectionStateReceivedResponse);
     // In the case of multipart loads, calls to didReceiveData & didReceiveResponse can be interleaved.
     RELEASE_ASSERT(isMultipartPayload || isValidStateTransition);
     m_connectionState = ConnectionStateReceivedResponse;
 
     const ResourceResponse& resourceResponse = response.toResourceResponse();
 
     if (responseNeedsAccessControlCheck()) {
         if (response.wasFetchedViaServiceWorker()) {
             if (response.wasFallbackRequiredByServiceWorker()) {
                 ASSERT(m_fallbackRequestForServiceWorker);
                 m_loader->cancel();
                 m_loader.clear();
                 m_connectionState = ConnectionStateStarted;
                 m_request = *m_fallbackRequestForServiceWorker;
-                m_loader = adoptPtr(blink::Platform::current()->createURLLoader());
+                m_loader = adoptPtr(Platform::current()->createURLLoader());
                 ASSERT(m_loader);
-                blink::WrappedResourceRequest wrappedRequest(m_request);
+                WrappedResourceRequest wrappedRequest(m_request);
                 m_loader->loadAsynchronously(wrappedRequest, this);
                 return;
             }
         } else {
             // If the response successfully validated a cached resource, perform
             // the access control with respect to it. Need to do this right here
             // before the resource switches clients over to that validated resource.
             Resource* resource = m_resource;
             if (resource->isCacheValidator() && resourceResponse.httpStatusCode() == 304)
                 resource = m_resource->resourceToRevalidate();
@@ skipping 20 matching lines @@
 
     if (response.toResourceResponse().isMultipart()) {
         if (!m_resource->isImage()) {
             cancel();
             return;
         }
     } else if (isMultipartPayload) {
         // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
         // After the first multipart section is complete, signal to delegates that this load is "finished"
         m_host->subresourceLoaderFinishedLoadingOnePart(this);
-        didFinishLoadingOnePart(0, blink::WebURLLoaderClient::kUnknownEncodedDataLength);
+        didFinishLoadingOnePart(0, WebURLLoaderClient::kUnknownEncodedDataLength);
     }
     if (m_state == Terminated)
         return;
 
     if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     m_state = Finishing;
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
         m_host->didFailLoading(m_resource, ResourceError::cancelledError(m_request.url()));
     }
 
     ASSERT(m_state != Terminated);
     m_resource->error(Resource::LoadError);
     cancel();
 }
 
-void ResourceLoader::didReceiveResponse(blink::WebURLLoader* loader, const blink::WebURLResponse& response)
+void ResourceLoader::didReceiveResponse(WebURLLoader* loader, const WebURLResponse& response)
 {
     didReceiveResponse(loader, response, nullptr);
 }
 
-void ResourceLoader::didReceiveData(blink::WebURLLoader*, const char* data, int length, int encodedDataLength)
+void ResourceLoader::didReceiveData(WebURLLoader*, const char* data, int length, int encodedDataLength)
 {
     ASSERT(m_state != Terminated);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     m_connectionState = ConnectionStateReceivingData;
 
     // It is possible to receive data on uninitialized resources if it had an error status code, and we are running a nested message
     // loop. When this occurs, ignoring the data is the correct action.
     if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     ASSERT(m_state == Initialized);
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
 
     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
     // However, with today's computers and networking speeds, this won't happen in practice.
     // Could be an issue with a giant local file.
     m_host->didReceiveData(m_resource, data, length, encodedDataLength);
     if (m_state == Terminated)
         return;
     RELEASE_ASSERT(length >= 0);
     m_resource->appendData(data, length);
 }
 
-void ResourceLoader::didFinishLoading(blink::WebURLLoader*, double finishTime, int64_t encodedDataLength)
+void ResourceLoader::didFinishLoading(WebURLLoader*, double finishTime, int64_t encodedDataLength)
 {
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse || m_connectionState == ConnectionStateReceivingData);
     m_connectionState = ConnectionStateFinishedLoading;
     if (m_state != Initialized)
         return;
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
 
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setLoadFinishTime(finishTime);
     didFinishLoadingOnePart(finishTime, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->finish();
 
     // If the load has been cancelled by a delegate in response to didFinishLoad(), do not release
     // the resources a second time, they have been released by cancel.
     if (m_state == Terminated)
         return;
     releaseResources();
 }
 
-void ResourceLoader::didFail(blink::WebURLLoader*, const blink::WebURLError& error)
+void ResourceLoader::didFail(WebURLLoader*, const WebURLError& error)
 {
     m_connectionState = ConnectionStateFailed;
     ASSERT(m_state != Terminated);
     WTF_LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setResourceError(error);
@@ skipping 13 matching lines @@
     releaseResources();
 }
 
 bool ResourceLoader::isLoadedBy(ResourceLoaderHost* loader) const
 {
     return m_host->isLoadedBy(loader);
 }
 
 void ResourceLoader::requestSynchronously()
 {
-    OwnPtr<blink::WebURLLoader> loader = adoptPtr(blink::Platform::current()->createURLLoader());
+    OwnPtr<WebURLLoader> loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(loader);
 
     // downloadToFile is not supported for synchronous requests.
     ASSERT(!m_request.downloadToFile());
 
     RefPtrWillBeRawPtr<ResourceLoader> protect(this);
     RefPtrWillBeRawPtr<ResourceLoaderHost> protectHost(m_host.get());
     ResourcePtr<Resource> protectResource(m_resource);
 
     RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
     m_connectionState = ConnectionStateStarted;
 
-    blink::WrappedResourceRequest requestIn(m_request);
-    blink::WebURLResponse responseOut;
+    WrappedResourceRequest requestIn(m_request);
+    WebURLResponse responseOut;
     responseOut.initialize();
-    blink::WebURLError errorOut;
-    blink::WebData dataOut;
+    WebURLError errorOut;
+    WebData dataOut;
     loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut);
     if (errorOut.reason) {
         didFail(0, errorOut);
         return;
     }
     didReceiveResponse(0, responseOut);
     if (m_state == Terminated)
         return;
     RefPtr<ResourceLoadInfo> resourceLoadInfo = responseOut.toResourceResponse().resourceLoadInfo();
-    int64_t encodedDataLength = resourceLoadInfo ? resourceLoadInfo->encodedDataLength : blink::WebURLLoaderClient::kUnknownEncodedDataLength;
+    int64_t encodedDataLength = resourceLoadInfo ? resourceLoadInfo->encodedDataLength : WebURLLoaderClient::kUnknownEncodedDataLength;
     m_host->didReceiveData(m_resource, dataOut.data(), dataOut.size(), encodedDataLength);
     m_resource->setResourceBuffer(dataOut);
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 ResourceRequest& ResourceLoader::applyOptions(ResourceRequest& request) const
 {
     request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     return request;
 }
 
 }