Replace FilePath with base::FilePath in some more top level directories.

printing/backend/print_backend_cups.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.
 
 #include "printing/backend/print_backend.h"
 
 #include "build/build_config.h"
 
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 110 matching lines @@
 
  protected:
   virtual ~PrintBackendCUPS() {}
 
  private:
   // Following functions are wrappers around corresponding CUPS functions.
   // <functions>2()  are called when print server is specified, and plain
   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
   // in the <functions>2(), it does not work in CUPS prior to 1.4.
   int GetDests(cups_dest_t** dests);
-  FilePath GetPPD(const char* name);
+  base::FilePath GetPPD(const char* name);
 
   GURL print_server_url_;
   http_encryption_t cups_encryption_;
   bool blocking_;
 };
 
 PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url,
                                    http_encryption_t encryption,
                                    bool blocking)
     : print_server_url_(print_server_url),
@@ skipping 86 matching lines @@
 }
 
 bool PrintBackendCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
     PrinterCapsAndDefaults* printer_info) {
   DCHECK(printer_info);
 
   VLOG(1) << "CUPS: Getting caps and defaults"
           << ", printer name: " << printer_name;
 
-  FilePath ppd_path(GetPPD(printer_name.c_str()));
+  base::FilePath ppd_path(GetPPD(printer_name.c_str()));
   // In some cases CUPS failed to get ppd file.
   if (ppd_path.empty()) {
     LOG(ERROR) << "CUPS: Failed to get PPD"
                << ", printer name: " << printer_name;
     return false;
   }
 
   std::string content;
   bool res = file_util::ReadFileToString(ppd_path, &content);
 
@@ skipping 76 matching lines @@
     http.SetBlocking(blocking_);
     return cupsGetDests2(http.http(), dests);
   }
 }
 
 FilePath PrintBackendCUPS::GetPPD(const char* name) {
   // cupsGetPPD returns a filename stored in a static buffer in CUPS.
   // Protect this code with lock.
   CR_DEFINE_STATIC_LOCAL(base::Lock, ppd_lock, ());
   base::AutoLock ppd_autolock(ppd_lock);
-  FilePath ppd_path;
+  base::FilePath ppd_path;
   const char* ppd_file_path = NULL;
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     ppd_file_path = cupsGetPPD(name);
     if (ppd_file_path)
-      ppd_path = FilePath(ppd_file_path);
+      ppd_path = base::FilePath(ppd_file_path);
   } else {
     // cupsGetPPD2 gets stuck sometimes in an infinite time due to network
     // configuration/issues. To prevent that, use non-blocking http connection
     // here.
     // Note: After looking at CUPS sources, it looks like non-blocking
     // connection will timeout after 10 seconds of no data period. And it will
     // return the same way as if data was completely and sucessfully downloaded.
     HttpConnectionCUPS http(print_server_url_, cups_encryption_);
     http.SetBlocking(blocking_);
     ppd_file_path = cupsGetPPD2(http.http(), name);
     // Check if the get full PPD, since non-blocking call may simply return
     // normally after timeout expired.
     if (ppd_file_path) {
       // There is no reliable way right now to detect full and complete PPD
       // get downloaded. If we reach http timeout, it may simply return
       // downloaded part as a full response. It might be good enough to check
       // http->data_remaining or http->_data_remaining, unfortunately http_t
       // is an internal structure and fields are not exposed in CUPS headers.
       // httpGetLength or httpGetLength2 returning the full content size.
       // Comparing file size against that content length might be unreliable
       // since some http reponses are encoded and content_length > file size.
       // Let's just check for the obvious CUPS and http errors here.
-      ppd_path = FilePath(ppd_file_path);
+      ppd_path = base::FilePath(ppd_file_path);
       ipp_status_t error_code = cupsLastError();
       int http_error = httpError(http.http());
       if (error_code > IPP_OK_EVENTS_COMPLETE || http_error != 0) {
         LOG(ERROR) << "Error downloading PPD file"
                    << ", name: " << name
                    << ", CUPS error: " << static_cast<int>(error_code)
                    << ", HTTP error: " << http_error;
         file_util::Delete(ppd_path, false);
         ppd_path.clear();
       }
     }
   }
   return ppd_path;
 }
 
 }  // namespace printing