Rename WebKit namespace to blink (part 3)

content/test/weburl_loader_mock_factory.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_TEST_WEBURL_LOADER_MOCK_FACTORY_H_
 #define CONTENT_TEST_WEBURL_LOADER_MOCK_FACTORY_H_
 
 #include <map>
 
 #include "base/files/file_path.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 
-namespace WebKit {
+namespace blink {
 class WebData;
 class WebURLLoader;
 }
 
 class WebURLLoaderMock;
 
 // A factory that creates WebURLLoaderMock to simulate resource loading in
 // tests.
 // You register files for specific URLs, the content of the file is then served
 // when these URLs are loaded.
 // In order to serve the asynchronous requests, you need to invoke
 // ServeAsynchronousRequest.
 class WebURLLoaderMockFactory {
  public:
   WebURLLoaderMockFactory();
   virtual ~WebURLLoaderMockFactory();
 
   // Called by TestWebKitPlatformSupport to create a WebURLLoader.
   // Non-mocked request are forwarded to |default_loader| which should not be
   // NULL.
-  virtual WebKit::WebURLLoader* CreateURLLoader(
-      WebKit::WebURLLoader* default_loader);
+  virtual blink::WebURLLoader* CreateURLLoader(
+      blink::WebURLLoader* default_loader);
 
   // Registers a response and the contents to be served when the specified URL
   // is loaded.
-  void RegisterURL(const WebKit::WebURL& url,
-                   const WebKit::WebURLResponse& response,
-                   const WebKit::WebString& filePath);
+  void RegisterURL(const blink::WebURL& url,
+                   const blink::WebURLResponse& response,
+                   const blink::WebString& filePath);
 
   // Registers an error to be served when the specified URL is requested.
-  void RegisterErrorURL(const WebKit::WebURL& url,
-                        const WebKit::WebURLResponse& response,
-                        const WebKit::WebURLError& error);
+  void RegisterErrorURL(const blink::WebURL& url,
+                        const blink::WebURLResponse& response,
+                        const blink::WebURLError& error);
 
   // Unregisters |url| so it will no longer be mocked.
-  void UnregisterURL(const WebKit::WebURL& url);
+  void UnregisterURL(const blink::WebURL& url);
 
   // Unregister all URLs so no URL will be mocked anymore.
   void UnregisterAllURLs();
 
   // Serves all the pending asynchronous requests.
   void ServeAsynchronousRequests();
 
   // Returns the last request handled by |ServeAsynchronousRequests()|.
-  WebKit::WebURLRequest GetLastHandledAsynchronousRequest();
+  blink::WebURLRequest GetLastHandledAsynchronousRequest();
 
   // Returns true if |url| was registered for being mocked.
-  bool IsMockedURL(const WebKit::WebURL& url);
+  bool IsMockedURL(const blink::WebURL& url);
 
   // Called by the loader to load a resource.
-  void LoadSynchronously(const WebKit::WebURLRequest& request,
-                         WebKit::WebURLResponse* response,
-                         WebKit::WebURLError* error,
-                         WebKit::WebData* data);
-  void LoadAsynchronouly(const WebKit::WebURLRequest& request,
+  void LoadSynchronously(const blink::WebURLRequest& request,
+                         blink::WebURLResponse* response,
+                         blink::WebURLError* error,
+                         blink::WebData* data);
+  void LoadAsynchronouly(const blink::WebURLRequest& request,
                          WebURLLoaderMock* loader);
 
   // Removes the loader from the list of pending loaders.
   void CancelLoad(WebURLLoaderMock* loader);
 
  private:
   struct ResponseInfo {
-    WebKit::WebURLResponse response;
+    blink::WebURLResponse response;
     base::FilePath file_path;
   };
 
 
   // Loads the specified request and populates the response, error and data
   // accordingly.
-  void LoadRequest(const WebKit::WebURLRequest& request,
-                   WebKit::WebURLResponse* response,
-                   WebKit::WebURLError* error,
-                   WebKit::WebData* data);
+  void LoadRequest(const blink::WebURLRequest& request,
+                   blink::WebURLResponse* response,
+                   blink::WebURLError* error,
+                   blink::WebData* data);
 
   // Checks if the loader is pending. Otherwise, it may have been deleted.
   bool IsPending(WebURLLoaderMock* loader);
 
   // Reads |m_filePath| and puts its content in |data|.
   // Returns true if it successfully read the file.
-  static bool ReadFile(const base::FilePath& file_path, WebKit::WebData* data);
+  static bool ReadFile(const base::FilePath& file_path, blink::WebData* data);
 
   // The loaders that have not being served data yet.
-  typedef std::map<WebURLLoaderMock*, WebKit::WebURLRequest> LoaderToRequestMap;
+  typedef std::map<WebURLLoaderMock*, blink::WebURLRequest> LoaderToRequestMap;
   LoaderToRequestMap pending_loaders_;
 
-  typedef std::map<GURL, WebKit::WebURLError> URLToErrorMap;
+  typedef std::map<GURL, blink::WebURLError> URLToErrorMap;
   URLToErrorMap url_to_error_info_;
 
   // Table of the registered URLs and the responses that they should receive.
   typedef std::map<GURL, ResponseInfo> URLToResponseMap;
   URLToResponseMap url_to_reponse_info_;
 
-  WebKit::WebURLRequest last_handled_asynchronous_request_;
+  blink::WebURLRequest last_handled_asynchronous_request_;
 
   DISALLOW_COPY_AND_ASSIGN(WebURLLoaderMockFactory);
 };
 
 #endif  // CONTENT_TEST_WEBURL_LOADER_MOCK_FACTORY_H_