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

ui/base/resource/resource_bundle_unittest.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 "ui/base/resource/resource_bundle.h"
 
 #include "base/base_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 40 matching lines @@
                                            0xc1, 0x30, 0x60, 0x4d };
 
 // Mock for the ResourceBundle::Delegate class.
 class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
  public:
   MockResourceBundleDelegate() {
   }
   virtual ~MockResourceBundleDelegate() {
   }
 
-  MOCK_METHOD2(GetPathForResourcePack, FilePath(const FilePath& pack_path,
-                                                ui::ScaleFactor scale_factor));
-  MOCK_METHOD2(GetPathForLocalePack, FilePath(const FilePath& pack_path,
-                                              const std::string& locale));
+  MOCK_METHOD2(GetPathForResourcePack, base::FilePath(
+      const base::FilePath& pack_path, ui::ScaleFactor scale_factor));
+  MOCK_METHOD2(GetPathForLocalePack, base::FilePath(
+      const base::FilePath& pack_path, const std::string& locale));
   MOCK_METHOD1(GetImageNamed, gfx::Image(int resource_id));
   MOCK_METHOD2(GetNativeImageNamed,
       gfx::Image(int resource_id,
                  ui::ResourceBundle::ImageRTL rtl));
   MOCK_METHOD2(LoadDataResourceBytes,
       base::RefCountedStaticMemory*(int resource_id,
                                     ui::ScaleFactor scale_factor));
   MOCK_METHOD2(GetRawDataResourceMock, base::StringPiece(
       int resource_id,
       ui::ScaleFactor scale_factor));
@@ skipping 37 matching lines @@
       kPngIHDRChunkType));
 
   bitmap_data->insert(ihdr_start + kPngChunkMetadataSize + ihdr_chunk_length,
                       custom_chunk.begin(), custom_chunk.end());
 }
 
 // Creates datapack at |path| with a single bitmap at resource ID 3
 // which is |edge_size|x|edge_size| pixels.
 // If |custom_chunk| is non empty, adds it after the IHDR chunk
 // in the encoded bitmap data.
-void CreateDataPackWithSingleBitmap(const FilePath& path,
+void CreateDataPackWithSingleBitmap(const base::FilePath& path,
                                     int edge_size,
                                     const base::StringPiece& custom_chunk) {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, edge_size, edge_size);
   bitmap.allocPixels();
   bitmap.eraseColor(SK_ColorWHITE);
   std::vector<unsigned char> bitmap_data;
   EXPECT_TRUE(gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &bitmap_data));
 
   if (custom_chunk.size() > 0)
@@ skipping 34 matching lines @@
   ResourceBundle* resource_bundle_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceBundleTest);
 };
 
 TEST_F(ResourceBundleTest, DelegateGetPathForResourcePack) {
   MockResourceBundleDelegate delegate;
   ResourceBundle* resource_bundle = CreateResourceBundle(&delegate);
 
-  FilePath pack_path(FILE_PATH_LITERAL("/path/to/test_path.pak"));
+  base::FilePath pack_path(FILE_PATH_LITERAL("/path/to/test_path.pak"));
   ui::ScaleFactor pack_scale_factor = ui::SCALE_FACTOR_200P;
 
   EXPECT_CALL(delegate,
       GetPathForResourcePack(
-          Property(&FilePath::value, pack_path.value()),
+          Property(&base::FilePath::value, pack_path.value()),
           pack_scale_factor))
       .Times(1)
       .WillOnce(Return(pack_path));
 
   resource_bundle->AddDataPackFromPath(pack_path, pack_scale_factor);
 }
 
 #if defined(OS_LINUX)
 // Fails consistently on Linux: crbug.com/161902
 #define MAYBE_DelegateGetPathForLocalePack DISABLED_DelegateGetPathForLocalePack
 #else
 #define MAYBE_DelegateGetPathForLocalePack DelegateGetPathForLocalePack
 #endif
 TEST_F(ResourceBundleTest, MAYBE_DelegateGetPathForLocalePack) {
   MockResourceBundleDelegate delegate;
   ResourceBundle* resource_bundle = CreateResourceBundle(&delegate);
 
   std::string locale = "en-US";
 
   // Cancel the load.
   EXPECT_CALL(delegate, GetPathForLocalePack(_, locale))
       .Times(2)
-      .WillRepeatedly(Return(FilePath()))
+      .WillRepeatedly(Return(base::FilePath()))
       .RetiresOnSaturation();
 
   EXPECT_FALSE(resource_bundle->LocaleDataPakExists(locale));
   EXPECT_EQ("", resource_bundle->LoadLocaleResources(locale));
 
   // Allow the load to proceed.
   EXPECT_CALL(delegate, GetPathForLocalePack(_, locale))
       .Times(2)
       .WillRepeatedly(ReturnArg<0>());
 
@@ skipping 125 matching lines @@
   }
 
   virtual void SetUp() OVERRIDE {
     // Create a temporary directory to write test resource bundles to.
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
   }
 
   // Returns resource bundle which uses an empty data pak for locale data.
   ui::ResourceBundle* CreateResourceBundleWithEmptyLocalePak() {
     // Write an empty data pak for locale data.
-    const FilePath& locale_path = dir_path().Append(
+    const base::FilePath& locale_path = dir_path().Append(
         FILE_PATH_LITERAL("locale.pak"));
     EXPECT_EQ(file_util::WriteFile(locale_path, kEmptyPakContents,
                                    kEmptyPakSize),
               static_cast<int>(kEmptyPakSize));
 
     ui::ResourceBundle* resource_bundle = CreateResourceBundle(NULL);
 
     // Load the empty locale data pak.
-    resource_bundle->LoadTestResources(FilePath(), locale_path);
+    resource_bundle->LoadTestResources(base::FilePath(), locale_path);
     return resource_bundle;
   }
 
   // Returns the path of temporary directory to write test data packs into.
-  const FilePath& dir_path() { return dir_.path(); }
+  const base::FilePath& dir_path() { return dir_.path(); }
 
  private:
   scoped_ptr<DataPack> locale_pack_;
   base::ScopedTempDir dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceBundleImageTest);
 };
 
 // Verify that we don't crash when trying to load a resource that is not found.
 // In some cases, we fail to mmap resources.pak, but try to keep going anyway.
 TEST_F(ResourceBundleImageTest, LoadDataResourceBytes) {
-  FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
+  base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak files.
   ASSERT_EQ(file_util::WriteFile(data_path, kEmptyPakContents,
       kEmptyPakSize), static_cast<int>(kEmptyPakSize));
 
   // Create a resource bundle from the file.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_100P);
 
   const int kUnfoundResourceId = 10000;
   EXPECT_EQ(NULL, resource_bundle->LoadDataResourceBytes(
       kUnfoundResourceId));
 
   // Give a .pak file that doesn't exist so we will fail to load it.
   resource_bundle->AddDataPackFromPath(
-      FilePath(FILE_PATH_LITERAL("non-existant-file.pak")),
+      base::FilePath(FILE_PATH_LITERAL("non-existant-file.pak")),
       ui::SCALE_FACTOR_NONE);
   EXPECT_EQ(NULL, resource_bundle->LoadDataResourceBytes(
       kUnfoundResourceId));
 }
 
 TEST_F(ResourceBundleImageTest, GetRawDataResource) {
-  FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
-  FilePath data_2x_path = dir_path().Append(FILE_PATH_LITERAL("sample_2x.pak"));
+  base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
+  base::FilePath data_2x_path =
+      dir_path().Append(FILE_PATH_LITERAL("sample_2x.pak"));
 
   // Dump contents into the pak files.
   ASSERT_EQ(file_util::WriteFile(data_path, kSamplePakContents,
       kSamplePakSize), static_cast<int>(kSamplePakSize));
   ASSERT_EQ(file_util::WriteFile(data_2x_path, kSamplePakContents2x,
       kSamplePakSize2x), static_cast<int>(kSamplePakSize2x));
 
   // Load the regular and 2x pak files.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_100P);
@@ skipping 10 matching lines @@
   // for both scale factor requests.
   EXPECT_EQ("this is id 6", resource_bundle->GetRawDataResourceForScale(6,
       SCALE_FACTOR_100P));
   EXPECT_EQ("this is id 6", resource_bundle->GetRawDataResourceForScale(6,
       SCALE_FACTOR_200P));
 }
 
 // Test requesting image reps at various scale factors from the image returned
 // via ResourceBundle::GetImageNamed().
 TEST_F(ResourceBundleImageTest, GetImageNamed) {
-  FilePath data_1x_path = dir_path().AppendASCII("sample_1x.pak");
-  FilePath data_2x_path = dir_path().AppendASCII("sample_2x.pak");
+  base::FilePath data_1x_path = dir_path().AppendASCII("sample_1x.pak");
+  base::FilePath data_2x_path = dir_path().AppendASCII("sample_2x.pak");
 
   // Create the pak files.
   CreateDataPackWithSingleBitmap(data_1x_path, 10, base::StringPiece());
   CreateDataPackWithSingleBitmap(data_2x_path, 20, base::StringPiece());
 
   // Load the regular and 2x pak files.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_1x_path, SCALE_FACTOR_100P);
   resource_bundle->AddDataPackFromPath(data_2x_path, SCALE_FACTOR_200P);
 
@@ skipping 19 matching lines @@
   // The 1.4x pack was not loaded. Requesting the 1.4x resource should return
   // either the 1x or the 2x resource.
   image_rep = image_skia->GetRepresentation(ui::SCALE_FACTOR_140P);
   EXPECT_TRUE(image_rep.scale_factor() == ui::SCALE_FACTOR_100P ||
               image_rep.scale_factor() == ui::SCALE_FACTOR_200P);
 }
 
 // Test that GetImageNamed() behaves properly for images which GRIT has
 // annotated as having fallen back to 1x.
 TEST_F(ResourceBundleImageTest, GetImageNamedFallback1x) {
-  FilePath data_path = dir_path().AppendASCII("sample.pak");
-  FilePath data_2x_path = dir_path().AppendASCII("sample_2x.pak");
+  base::FilePath data_path = dir_path().AppendASCII("sample.pak");
+  base::FilePath data_2x_path = dir_path().AppendASCII("sample_2x.pak");
 
   // Create the pak files.
   CreateDataPackWithSingleBitmap(data_path, 10, base::StringPiece());
   // 2x data pack bitmap has custom chunk to indicate that the 2x bitmap is not
   // available and that GRIT fell back to 1x.
   CreateDataPackWithSingleBitmap(data_2x_path, 10, base::StringPiece(
       reinterpret_cast<const char*>(kPngScaleChunk),
       arraysize(kPngScaleChunk)));
 
   // Load the regular and 2x pak files.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_100P);
   resource_bundle->AddDataPackFromPath(data_2x_path, SCALE_FACTOR_200P);
 
   gfx::ImageSkia* image_skia = resource_bundle->GetImageSkiaNamed(3);
 
   // The image rep for 2x should be available. It should be resized to the
   // proper 2x size.
   gfx::ImageSkiaRep image_rep =
     image_skia->GetRepresentation(ui::SCALE_FACTOR_200P);
   EXPECT_EQ(ui::SCALE_FACTOR_200P, image_rep.scale_factor());
   EXPECT_EQ(20, image_rep.pixel_width());
   EXPECT_EQ(20, image_rep.pixel_height());
 }
 
 TEST_F(ResourceBundleImageTest, FallbackToNone) {
-  FilePath data_default_path = dir_path().AppendASCII("sample.pak");
+  base::FilePath data_default_path = dir_path().AppendASCII("sample.pak");
 
   // Create the pak files.
   CreateDataPackWithSingleBitmap(data_default_path, 10, base::StringPiece());
 
     // Load the regular pak files only.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_default_path, SCALE_FACTOR_NONE);
 
   gfx::ImageSkia* image_skia = resource_bundle->GetImageSkiaNamed(3);
   EXPECT_EQ(1u, image_skia->image_reps().size());
   EXPECT_EQ(ui::SCALE_FACTOR_100P,
             image_skia->image_reps()[0].scale_factor());
 }
 
 }  // namespace ui