Use base namespace for FilePath in content/browser

content/browser/gpu/gpu_pixel_browsertest.cc

 // Copyright (c) 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.
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 34 matching lines @@
 // Command line flag for overriding the default location for putting generated
 // test images that do not match references.
 const char kGeneratedDir[] = "generated-dir";
 // Command line flag for overriding the default location for reference images.
 const char kReferenceDir[] = "reference-dir";
 // Command line flag for Chromium build revision.
 const char kBuildRevision[] = "build-revision";
 
 // Reads and decodes a PNG image to a bitmap. Returns true on success. The PNG
 // should have been encoded using |gfx::PNGCodec::Encode|.
-bool ReadPNGFile(const FilePath& file_path, SkBitmap* bitmap) {
+bool ReadPNGFile(const base::FilePath& file_path, SkBitmap* bitmap) {
   DCHECK(bitmap);
-  FilePath abs_path(file_path);
+  base::FilePath abs_path(file_path);
   if (!file_util::AbsolutePath(&abs_path))
     return false;
 
   std::string png_data;
   return file_util::ReadFileToString(abs_path, &png_data) &&
          gfx::PNGCodec::Decode(reinterpret_cast<unsigned char*>(&png_data[0]),
                                png_data.length(),
                                bitmap);
 }
 
 // Encodes a bitmap into a PNG and write to disk. Returns true on success. The
 // parent directory does not have to exist.
-bool WritePNGFile(const SkBitmap& bitmap, const FilePath& file_path) {
+bool WritePNGFile(const SkBitmap& bitmap, const base::FilePath& file_path) {
   std::vector<unsigned char> png_data;
   if (gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, true, &png_data) &&
       file_util::CreateDirectory(file_path.DirName())) {
     int bytes_written = file_util::WriteFile(
         file_path, reinterpret_cast<char*>(&png_data[0]), png_data.size());
     if (bytes_written == static_cast<int>(png_data.size()))
       return true;
   }
   return false;
 }
 
 // Write an empty file, whose name indicates the chrome revision when the ref
 // image was generated.
-bool WriteREVFile(const FilePath& file_path) {
+bool WriteREVFile(const base::FilePath& file_path) {
   if (file_util::CreateDirectory(file_path.DirName())) {
     char one_byte = 0;
     int bytes_written = file_util::WriteFile(file_path, &one_byte, 1);
     if (bytes_written == 1)
       return true;
   }
   return false;
 }
 
 }  // namespace anonymous
@@ skipping 54 matching lines @@
       ReplaceFirstSubstringAfterOffset(
           &test_name_, 0, test_status_prefixes[i], "");
     }
 
     ui::DisableTestCompositor();
   }
 
   // If the existing ref image was saved from an revision older than the
   // ref_img_update_revision, refresh the ref image.
   void RunPixelTest(const gfx::Size& tab_container_size,
-                    const FilePath& url,
+                    const base::FilePath& url,
                     int64 ref_img_update_revision,
                     const ReferencePixel* ref_pixels,
                     size_t ref_pixel_count) {
     if (ref_img_option_ == kReferenceImageLocal) {
       ref_img_revision_no_older_than_ = ref_img_update_revision;
       ObtainLocalRefImageRevision();
     }
 
     DOMMessageQueue message_queue;
     NavigateToURL(shell(), net::FilePathToFileURL(url));
 
     std::string message;
     // Wait for notification that page is loaded.
     ASSERT_TRUE(message_queue.WaitForMessage(&message));
     EXPECT_STREQ("\"SUCCESS\"", message.c_str()) << message;
 
     SkBitmap bitmap;
     ASSERT_TRUE(TabSnapShotToImage(&bitmap, tab_container_size));
     bool same_pixels = true;
     if (ref_img_option_ == kReferenceImageNone && ref_pixels && ref_pixel_count)
       same_pixels = ComparePixels(bitmap, ref_pixels, ref_pixel_count);
     else
       same_pixels = CompareImages(bitmap);
     EXPECT_TRUE(same_pixels);
   }
 
-  const FilePath& test_data_dir() const {
+  const base::FilePath& test_data_dir() const {
     return test_data_dir_;
   }
 
  private:
-  FilePath test_data_dir_;
-  FilePath generated_img_dir_;
-  FilePath ref_img_dir_;
+  base::FilePath test_data_dir_;
+  base::FilePath generated_img_dir_;
+  base::FilePath ref_img_dir_;
   int64 ref_img_revision_;
   std::string build_revision_;
   // The name of the test, with any special prefixes dropped.
   std::string test_name_;
 
   // Any local ref image generated from older revision is ignored.
   int64 ref_img_revision_no_older_than_;
 
   // Whether use locally generated ref images, or checked in ref images, or
   // simply check a few key pixels.
@@ skipping 10 matching lines @@
   // The number is the chromium revision that generated the image.
   //
   // On failure or on ref image generation, the image and diff image will be
   // written to disk. The formats are:
   //     FAIL_<ref_image_name>, DIFF_<ref_image_name>
   // E.g.,
   //     FAIL_WebGLTeapot_19762.png, DIFF_WebGLTeapot_19762.png
   bool CompareImages(const SkBitmap& gen_bmp) {
     SkBitmap ref_bmp_on_disk;
 
-    FilePath img_path = ref_img_dir_.AppendASCII(test_name_ + ".png");
+    base::FilePath img_path = ref_img_dir_.AppendASCII(test_name_ + ".png");
     bool found_ref_img = ReadPNGFile(img_path, &ref_bmp_on_disk);
 
     if (!found_ref_img && ref_img_option_ == kReferenceImageCheckedIn) {
       LOG(ERROR) << "Couldn't find reference image: "
                  << img_path.value();
       // No image to compare to, exit early.
       return false;
     }
 
     const SkBitmap* ref_bmp;
     bool save_gen = false;
     bool save_diff = true;
     bool rt = true;
 
     if ((ref_img_revision_ <= 0 && ref_img_option_ == kReferenceImageLocal) ||
         !found_ref_img) {
-      FilePath rev_path = ref_img_dir_.AppendASCII(
+      base::FilePath rev_path = ref_img_dir_.AppendASCII(
           test_name_ + "_" + build_revision_ + ".rev");
       if (!WritePNGFile(gen_bmp, img_path)) {
         LOG(ERROR) << "Can't save generated image to: "
                    << img_path.value()
                    << " as future reference.";
         rt = false;
       } else {
         LOG(INFO) << "Saved reference image to: "
                   << img_path.value();
       }
@@ skipping 62 matching lines @@
         if (ref_img_option_ == kReferenceImageLocal) {
           save_gen = true;
           save_diff = true;
         }
         rt = false;
       }
     }
 
     std::string ref_img_filename = img_path.BaseName().MaybeAsASCII();
     if (save_gen) {
-      FilePath img_fail_path = generated_img_dir_.AppendASCII(
+      base::FilePath img_fail_path = generated_img_dir_.AppendASCII(
           "FAIL_" + ref_img_filename);
       if (!WritePNGFile(gen_bmp, img_fail_path)) {
         LOG(ERROR) << "Can't save generated image to: "
                    << img_fail_path.value();
       } else {
         LOG(INFO) << "Saved generated image to: "
                   << img_fail_path.value();
       }
     }
     if (save_diff) {
-      FilePath img_diff_path = generated_img_dir_.AppendASCII(
+      base::FilePath img_diff_path = generated_img_dir_.AppendASCII(
           "DIFF_" + ref_img_filename);
       if (!WritePNGFile(diff_bmp, img_diff_path)) {
         LOG(ERROR) << "Can't save generated diff image to: "
                    << img_diff_path.value();
       } else {
         LOG(INFO) << "Saved difference image to: "
                   << img_diff_path.value();
       }
     }
     return rt;
@@ skipping 43 matching lines @@
     if (!gfx::PNGCodec::Decode(reinterpret_cast<unsigned char*>(&*png.begin()),
                                png.size(), bitmap)) {
       LOG(ERROR) << "Decode PNG to a SkBitmap failed";
       return false;
     }
     return true;
   }
 
   // If no valid local revision file is located, the ref_img_revision_ is 0.
   void ObtainLocalRefImageRevision() {
-    FilePath filter;
+    base::FilePath filter;
     filter = filter.AppendASCII(test_name_ + "_*.rev");
     file_util::FileEnumerator locator(ref_img_dir_,
                                       false,  // non recursive
                                       file_util::FileEnumerator::FILES,
                                       filter.value());
     int64 max_revision = 0;
-    std::vector<FilePath> outdated_revs;
-    for (FilePath full_path = locator.Next();
+    std::vector<base::FilePath> outdated_revs;
+    for (base::FilePath full_path = locator.Next();
          !full_path.empty();
          full_path = locator.Next()) {
       std::string filename =
           full_path.BaseName().RemoveExtension().MaybeAsASCII();
       std::string revision_string =
           filename.substr(test_name_.length() + 1);
       int64 revision = 0;
       bool converted = base::StringToInt64(revision_string, &revision);
       if (!converted)
         continue;
@@ skipping 22 matching lines @@
     {50, 100, 0, 0, 0},
     {100, 100, 0, 255, 0},
     {150, 100, 0, 0, 0},
     {50, 150, 0, 255, 0},
     {100, 150, 0, 255, 0},
     {150, 150, 0, 255, 0}
   };
   const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
 
   gfx::Size container_size(400, 300);
-  FilePath url =
+  base::FilePath url =
       test_data_dir().AppendASCII("pixel_webgl.html");
   RunPixelTest(container_size, url, ref_img_revision_update,
                ref_pixels, ref_pixel_count);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuPixelBrowserTest, MANUAL_CSS3DBlueBox) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
   const ReferencePixel ref_pixels[] = {
     // x, y, r, g, b
     {70, 50, 0, 0, 255},
     {150, 50, 0, 0, 0},
     {70, 90, 0, 0, 255},
     {150, 90, 0, 0, 255},
     {70, 125, 0, 0, 255},
     {150, 125, 0, 0, 0}
   };
   const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
 
   gfx::Size container_size(400, 300);
-  FilePath url =
+  base::FilePath url =
       test_data_dir().AppendASCII("pixel_css3d.html");
   RunPixelTest(container_size, url, ref_img_revision_update,
                ref_pixels, ref_pixel_count);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuPixelBrowserTest, MANUAL_Canvas2DRedBoxHD) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
   const ReferencePixel ref_pixels[] = {
     // x, y, r, g, b
     {40, 100, 0, 0, 0},
     {60, 100, 127, 0, 0},
     {140, 100, 127, 0, 0},
     {160, 100, 0, 0, 0}
   };
   const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
 
   gfx::Size container_size(400, 300);
-  FilePath url =
+  base::FilePath url =
       test_data_dir().AppendASCII("pixel_canvas2d.html");
   RunPixelTest(container_size, url, ref_img_revision_update,
                ref_pixels, ref_pixel_count);
 }
 
 class GpuPixelTestCanvas2DSD : public GpuPixelBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuPixelBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(GpuPixelTestCanvas2DSD, MANUAL_Canvas2DRedBoxSD) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
   const ReferencePixel ref_pixels[] = {
     // x, y, r, g, b
     {40, 100, 0, 0, 0},
     {60, 100, 127, 0, 0},
     {140, 100, 127, 0, 0},
     {160, 100, 0, 0, 0}
   };
   const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
 
   gfx::Size container_size(400, 300);
-  FilePath url =
+  base::FilePath url =
       test_data_dir().AppendASCII("pixel_canvas2d.html");
   RunPixelTest(container_size, url, ref_img_revision_update,
                ref_pixels, ref_pixel_count);
 }
 
 }  // namespace content