Add FilePath to base namespace.

webkit/tools/test_shell/simple_resource_loader_bridge.cc

 // Copyright (c) 2012 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 contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 75 matching lines @@
 using webkit_glue::ResourceRequestBody;
 using webkit_glue::ResourceResponseInfo;
 using net::StaticCookiePolicy;
 using net::HttpResponseHeaders;
 using webkit_blob::ShareableFileReference;
 
 namespace {
 
 struct TestShellRequestContextParams {
   TestShellRequestContextParams(
-      const FilePath& in_cache_path,
+      const base::FilePath& in_cache_path,
       net::HttpCache::Mode in_cache_mode,
       bool in_no_proxy)
       : cache_path(in_cache_path),
         cache_mode(in_cache_mode),
         no_proxy(in_no_proxy) {}
 
-  FilePath cache_path;
+  base::FilePath cache_path;
   net::HttpCache::Mode cache_mode;
   bool no_proxy;
 };
 
 //-----------------------------------------------------------------------------
 
 bool g_accept_all_cookies = false;
 
 class TestShellNetworkDelegate : public net::NetworkDelegate {
  public:
@@ skipping 56 matching lines @@
     StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
         StaticCookiePolicy::ALLOW_ALL_COOKIES :
         StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
 
     StaticCookiePolicy policy(policy_type);
     int rv = policy.CanSetCookie(
         request.url(), request.first_party_for_cookies());
     return rv == net::OK;
   }
   virtual bool OnCanAccessFile(const net::URLRequest& request,
-                               const FilePath& path) const OVERRIDE {
+                               const base::FilePath& path) const OVERRIDE {
     return true;
   }
   virtual bool OnCanThrottleRequest(
       const net::URLRequest& request) const OVERRIDE {
     return false;
   }
 
   virtual int OnBeforeSocketStreamConnect(
       net::SocketStream* stream,
       const net::CompletionCallback& callback) OVERRIDE {
@@ skipping 277 matching lines @@
               blob_storage_controller(),
               static_cast<TestShellRequestContext*>(g_request_context)->
               file_system_context(),
               base::MessageLoopProxy::current())));
     }
     SimpleAppCacheSystem::SetExtraRequestInfo(
         request_.get(), params->appcache_host_id, params->request_type);
 
     download_to_file_ = params->download_to_file;
     if (download_to_file_) {
-      FilePath path;
+      base::FilePath path;
       if (file_util::CreateTemporaryFile(&path)) {
         downloaded_file_ = ShareableFileReference::GetOrCreate(
             path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
             base::MessageLoopProxy::current());
         file_stream_.reset(new net::FileStream(NULL));
         file_stream_->OpenSync(
             path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE);
       }
     }
 
@@ skipping 259 matching lines @@
     const FileOverHTTPParams* redirection_params =
         g_file_over_http_mappings->ParamsForResponse(original_request);
     DCHECK(redirection_params);
 
     std::string http_prefix = redirection_params->http_prefix.spec();
     DCHECK(StartsWithASCII(original_request, http_prefix, true));
 
     // Get the File URL.
     original_request.replace(0, http_prefix.size(), file_url_prefix_);
 
-    FilePath file_path;
+    base::FilePath file_path;
     if (!net::FileURLToFilePath(GURL(original_request), &file_path)) {
       NOTREACHED();
     }
 
     info->mime_type.clear();
     DCHECK(info->headers);
     int status_code = info->headers->response_code();
     // File protocol does not support response headers.
     info->headers = NULL;
     if (200 == status_code) {
@@ skipping 251 matching lines @@
   base::WaitableEvent event_;
   std::string result_;
 };
 
 }  // anonymous namespace
 
 //-----------------------------------------------------------------------------
 
 // static
 void SimpleResourceLoaderBridge::Init(
-    const FilePath& cache_path,
+    const base::FilePath& cache_path,
     net::HttpCache::Mode cache_mode,
     bool no_proxy) {
   // Make sure to stop any existing IO thread since it may be using the
   // current request context.
   Shutdown();
 
   DCHECK(!g_request_context_params);
   DCHECK(!g_request_context);
   DCHECK(!g_network_delegate);
   DCHECK(!g_io_thread);
@@ skipping 112 matching lines @@
   if (!g_file_over_http_mappings)
     g_file_over_http_mappings = new FileOverHTTPPathMappings();
   g_file_over_http_mappings->AddMapping(file_path_template, http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }