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

tools/imagediff/image_diff.cc

 // Copyright (c) 2011 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 input format is based loosely on
 // Tools/DumpRenderTree/ImageDiff.m
 
 // The exact format of this tool's output to stdout is important, to match
 // what the run-webkit-tests script expects.
 
@@ skipping 73 matching lines @@
                                gfx::PNGCodec::FORMAT_RGBA,
                                &data_, &w_, &h_)) {
       Clear();
       return false;
     }
     return true;
   }
 
   // Creates the image from the given filename on disk, and returns true on
   // success.
-  bool CreateFromFilename(const FilePath& path) {
+  bool CreateFromFilename(const base::FilePath& path) {
     FILE* f = file_util::OpenFile(path, "rb");
     if (!f)
       return false;
 
     std::vector<unsigned char> compressed;
     const int buf_size = 1024;
     unsigned char buf[buf_size];
     size_t num_read = 0;
     while ((num_read = fread(buf, 1, buf_size, f)) > 0) {
       compressed.insert(compressed.end(), buf, buf + num_read);
@@ skipping 81 matching lines @@
   /* For unfinished webkit-like-mode (see below)
     "\n"
     "  image_diff -s\n"
     "    Reads stream input from stdin, should be EXACTLY of the format\n"
     "    \"Content-length: <byte length> <data>Content-length: ...\n"
     "    it will take as many file pairs as given, and will compare them as\n"
     "    (cmp_file, reference_file) pairs\n");
   */
 }
 
-int CompareImages(const FilePath& file1, const FilePath& file2) {
+int CompareImages(const base::FilePath& file1, const base::FilePath& file2) {
   Image actual_image;
   Image baseline_image;
 
   if (!actual_image.CreateFromFilename(file1)) {
     fprintf(stderr, "image_diff: Unable to open file \"%" PRFilePath "\"\n",
             file1.value().c_str());
     return kStatusError;
   }
   if (!baseline_image.CreateFromFilename(file2)) {
     fprintf(stderr, "image_diff: Unable to open file \"%" PRFilePath "\"\n",
@@ skipping 80 matching lines @@
         uint32 alpha = base_pixel & RGBA_ALPHA;
         uint32 new_pixel = base_pixel - ((alpha / 2) & RGBA_ALPHA);
         out->set_pixel_at(x, y, new_pixel);
       }
     }
   }
 
   return same;
 }
 
-int DiffImages(const FilePath& file1, const FilePath& file2,
-               const FilePath& out_file) {
+int DiffImages(const base::FilePath& file1, const base::FilePath& file2,
+               const base::FilePath& out_file) {
   Image actual_image;
   Image baseline_image;
 
   if (!actual_image.CreateFromFilename(file1)) {
     fprintf(stderr, "image_diff: Unable to open file \"%" PRFilePath "\"\n",
             file1.value().c_str());
     return kStatusError;
   }
   if (!baseline_image.CreateFromFilename(file2)) {
     fprintf(stderr, "image_diff: Unable to open file \"%" PRFilePath "\"\n",
@@ skipping 14 matching lines @@
   if (file_util::WriteFile(out_file,
       reinterpret_cast<char*>(&png_encoding.front()), png_encoding.size()) < 0)
     return kStatusError;
 
   return kStatusDifferent;
 }
 
 // It isn't strictly correct to only support ASCII paths, but this
 // program reads paths on stdin and the program that spawns it outputs
 // paths as non-wide strings anyway.
-FilePath FilePathFromASCII(const std::string& str) {
+base::FilePath FilePathFromASCII(const std::string& str) {
 #if defined(OS_WIN)
-  return FilePath(ASCIIToWide(str));
+  return base::FilePath(ASCIIToWide(str));
 #else
-  return FilePath(str);
+  return base::FilePath(str);
 #endif
 }
 
 int main(int argc, const char* argv[]) {
   base::EnableTerminationOnHeapCorruption();
   CommandLine::Init(argc, argv);
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(kOptionPollStdin)) {
     // Watch stdin for filenames.
     std::string stdin_buffer;
-    FilePath filename1;
+    base::FilePath filename1;
     while (std::getline(std::cin, stdin_buffer)) {
       if (stdin_buffer.empty())
         continue;
 
       if (!filename1.empty()) {
         // CompareImages writes results to stdout unless an error occurred.
-        FilePath filename2 = FilePathFromASCII(stdin_buffer);
+        base::FilePath filename2 = FilePathFromASCII(stdin_buffer);
         if (CompareImages(filename1, filename2) == kStatusError)
           printf("error\n");
         fflush(stdout);
-        filename1 = FilePath();
+        filename1 = base::FilePath();
       } else {
         // Save the first filename in another buffer and wait for the second
         // filename to arrive via stdin.
         filename1 = FilePathFromASCII(stdin_buffer);
       }
     }
     return 0;
   }
 
   const CommandLine::StringVector& args = parsed_command_line.GetArgs();
   if (parsed_command_line.HasSwitch(kOptionGenerateDiff)) {
     if (args.size() == 3) {
-      return DiffImages(FilePath(args[0]),
-                        FilePath(args[1]),
-                        FilePath(args[2]));
+      return DiffImages(base::FilePath(args[0]),
+                        base::FilePath(args[1]),
+                        base::FilePath(args[2]));
     }
   } else if (args.size() == 2) {
-    return CompareImages(FilePath(args[0]), FilePath(args[1]));
+    return CompareImages(base::FilePath(args[0]), base::FilePath(args[1]));
   }
 
   PrintHelp();
   return kStatusError;
 }