Disable "using base::FilePath" on Linux since it now compiles.

chrome/browser/chromeos/extensions/wallpaper_private_api.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 "chrome/browser/chromeos/extensions/wallpaper_private_api.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/wm/window_cycle_controller.h"
@@ skipping 67 matching lines @@
 
   return file_util::PathExists(file_path) ||
          (file_util::WriteFile(file_path, data.c_str(),
                                data.size()) != -1);
 }
 
 // Gets |file_name| from directory with |key|. Return false if the directory can
 // not be found or failed to read file to string |data|. Note if the |file_name|
 // can not be found in the directory, return true with empty |data|. It is
 // expected that we may try to access file which did not saved yet.
-bool GetData(const FilePath& path, std::string* data) {
-  FilePath data_dir = path.DirName();
+bool GetData(const base::FilePath& path, std::string* data) {
+  base::FilePath data_dir = path.DirName();
   if (!file_util::DirectoryExists(data_dir) &&
       !file_util::CreateDirectory(data_dir))
     return false;
 
   return !file_util::PathExists(path) ||
          file_util::ReadFileToString(path, data);
 }
 
 class WindowStateManager;
 
@@ skipping 404 matching lines @@
 }
 
 void WallpaperPrivateSetCustomWallpaperFunction::OnWallpaperDecoded(
     const gfx::ImageSkia& wallpaper) {
   chromeos::WallpaperManager* wallpaper_manager =
       chromeos::WallpaperManager::Get();
   chromeos::UserImage::RawImage raw_image(image_data_.begin(),
                                           image_data_.end());
   chromeos::UserImage image(wallpaper, raw_image);
   std::string file = base::Int64ToString(base::Time::Now().ToInternalValue());
-  FilePath thumbnail_path = wallpaper_manager->GetCustomWallpaperPath(
+  base::FilePath thumbnail_path = wallpaper_manager->GetCustomWallpaperPath(
       chromeos::kThumbnailWallpaperSubDir, email_, file);
 
   sequence_token_ = BrowserThread::GetBlockingPool()->
       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 
   wallpaper.EnsureRepsForSupportedScaleFactors();
   scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.DeepCopy());
   // Generates thumbnail before call api function callback. We can then request
   // thumbnail in the javascript callback.
   task_runner->PostTask(FROM_HERE,
       base::Bind(&WallpaperPrivateSetCustomWallpaperFunction::GenerateThumbnail,
                  this, thumbnail_path, base::Passed(&deep_copy)));
 
   // In the new wallpaper picker UI, we do not depend on WallpaperDelegate
   // to refresh thumbnail. Uses a null delegate here.
   wallpaper_manager->SetCustomWallpaper(email_, file, layout_,
                                         chromeos::User::CUSTOMIZED,
                                         image);
   wallpaper_decoder_ = NULL;
 }
 
 void WallpaperPrivateSetCustomWallpaperFunction::GenerateThumbnail(
-    const FilePath& thumbnail_path, scoped_ptr<gfx::ImageSkia> image) {
+    const base::FilePath& thumbnail_path, scoped_ptr<gfx::ImageSkia> image) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   chromeos::UserImage wallpaper(*image.get());
   if (!file_util::PathExists(thumbnail_path.DirName()))
     file_util::CreateDirectory(thumbnail_path.DirName());
 
   chromeos::WallpaperManager::Get()->ResizeAndSaveWallpaper(
       wallpaper,
       thumbnail_path,
       ash::WALLPAPER_LAYOUT_STRETCH,
@@ skipping 45 matching lines @@
 bool WallpaperPrivateGetThumbnailFunction::RunImpl() {
   std::string urlOrFile;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &urlOrFile));
   EXTENSION_FUNCTION_VALIDATE(!urlOrFile.empty());
 
   std::string source;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &source));
   EXTENSION_FUNCTION_VALIDATE(!source.empty());
 
   std::string file_name;
-  FilePath thumbnail_path;
+  base::FilePath thumbnail_path;
   std::string email = chromeos::UserManager::Get()->GetLoggedInUser()->email();
   if (source == kOnlineSource) {
     file_name = GURL(urlOrFile).ExtractFileName();
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS,
                            &thumbnail_path));
     thumbnail_path = thumbnail_path.Append(file_name);
   } else {
     file_name = urlOrFile;
     thumbnail_path = chromeos::WallpaperManager::Get()->
         GetCustomWallpaperPath(chromeos::kThumbnailWallpaperSubDir, email,
@@ skipping 25 matching lines @@
 }
 
 void WallpaperPrivateGetThumbnailFunction::FileLoaded(
     const std::string& data) {
   BinaryValue* thumbnail = BinaryValue::CreateWithCopiedBuffer(data.c_str(),
                                                                data.size());
   SetResult(thumbnail);
   SendResponse(true);
 }
 
-void WallpaperPrivateGetThumbnailFunction::Get(const FilePath& path) {
+void WallpaperPrivateGetThumbnailFunction::Get(const base::FilePath& path) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::string data;
   if (GetData(path, &data)) {
     if (data.empty()) {
       BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&WallpaperPrivateGetThumbnailFunction::FileNotLoaded, this));
     } else {
       BrowserThread::PostTask(
@@ skipping 94 matching lines @@
   return true;
 }
 
 void WallpaperPrivateGetOfflineWallpaperListFunction::GetList(
     const std::string& email,
     const std::string& source) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::vector<std::string> file_list;
   if (source == kOnlineSource) {
-    FilePath wallpaper_dir;
+    base::FilePath wallpaper_dir;
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     if (file_util::DirectoryExists(wallpaper_dir)) {
       file_util::FileEnumerator files(wallpaper_dir, false,
                                       file_util::FileEnumerator::FILES);
-      for (FilePath current = files.Next(); !current.empty();
+      for (base::FilePath current = files.Next(); !current.empty();
            current = files.Next()) {
         std::string file_name = current.BaseName().RemoveExtension().value();
         // Do not add file name of small resolution wallpaper to the list.
         if (!EndsWith(file_name, chromeos::kSmallWallpaperSuffix, true))
           file_list.push_back(current.BaseName().value());
       }
     }
   } else {
-    FilePath custom_thumbnails_dir = chromeos::WallpaperManager::Get()->
+    base::FilePath custom_thumbnails_dir = chromeos::WallpaperManager::Get()->
         GetCustomWallpaperPath(chromeos::kThumbnailWallpaperSubDir, email, "");
     if (file_util::DirectoryExists(custom_thumbnails_dir)) {
       file_util::FileEnumerator files(custom_thumbnails_dir, false,
                                       file_util::FileEnumerator::FILES);
-      for (FilePath current = files.Next(); !current.empty();
+      for (base::FilePath current = files.Next(); !current.empty();
            current = files.Next()) {
         file_list.push_back(current.BaseName().value());
       }
     }
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete,
                  this, file_list));
 }
 
 void WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete(
     const std::vector<std::string>& file_list) {
   ListValue* results = new ListValue();
   results->AppendStrings(file_list);
   SetResult(results);
   SendResponse(true);
 }