Rename FilePath -> base::FilePath in various toplevel directories

ash/system/drive/tray_drive.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 "ash/system/drive/tray_drive.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray.h"
@@ skipping 123 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(OperationProgressBar);
   };
 
   class RowView : public HoverHighlightView,
                   public views::ButtonListener {
    public:
     RowView(DriveDetailedView* parent,
             ash::DriveOperationStatus::OperationState state,
             double progress,
-            const FilePath& file_path)
+            const base::FilePath& file_path)
         : HoverHighlightView(parent),
           container_(parent),
           status_img_(NULL),
           label_container_(NULL),
           progress_bar_(NULL),
           cancel_button_(NULL),
           file_path_(file_path) {
       // Status image.
       status_img_ = new views::ImageView();
       AddChildView(status_img_);
@@ skipping 97 matching lines @@
                                const ui::Event& event) OVERRIDE {
       DCHECK(sender == cancel_button_);
       container_->OnCancelOperation(file_path_);
     }
 
     DriveDetailedView* container_;
     views::ImageView* status_img_;
     views::View* label_container_;
     views::ProgressBar* progress_bar_;
     views::ImageButton* cancel_button_;
-    FilePath file_path_;
+    base::FilePath file_path_;
 
     DISALLOW_COPY_AND_ASSIGN(RowView);
   };
 
   void AppendHeaderEntry(const DriveOperationStatusList* list) {
     if (footer())
       return;
     CreateSpecialRow(IDS_ASH_STATUS_TRAY_DRIVE, this);
   }
 
   gfx::ImageSkia* GetImageForState(
       ash::DriveOperationStatus::OperationState state) {
     switch (state) {
       case ash::DriveOperationStatus::OPERATION_NOT_STARTED:
       case ash::DriveOperationStatus::OPERATION_STARTED:
       case ash::DriveOperationStatus::OPERATION_IN_PROGRESS:
       case ash::DriveOperationStatus::OPERATION_SUSPENDED:
         return in_progress_img_;
       case ash::DriveOperationStatus::OPERATION_COMPLETED:
         return done_img_;
       case ash::DriveOperationStatus::OPERATION_FAILED:
         return failed_img_;
     }
     return failed_img_;
   }
 
-  virtual void OnCancelOperation(const FilePath& file_path) {
+  virtual void OnCancelOperation(const base::FilePath& file_path) {
     SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
     delegate->CancelDriveOperation(file_path);
   }
 
   void AppendOperationList(const DriveOperationStatusList* list) {
     if (!scroller())
       CreateScrollableList();
 
     // Apply the update.
-    std::set<FilePath> new_set;
+    std::set<base::FilePath> new_set;
     bool item_list_changed = false;
     for (DriveOperationStatusList::const_iterator it = list->begin();
          it != list->end(); ++it) {
       const DriveOperationStatus& operation = *it;
 
       new_set.insert(operation.file_path);
-      std::map<FilePath, RowView*>::iterator existing_item =
+      std::map<base::FilePath, RowView*>::iterator existing_item =
           update_map_.find(operation.file_path);
 
       if (existing_item != update_map_.end()) {
         existing_item->second->UpdateStatus(operation.state,
                                             operation.progress);
       } else {
         RowView* row_view = new RowView(this,
                                         operation.state,
                                         operation.progress,
                                         operation.file_path);
 
         update_map_[operation.file_path] = row_view;
         scroll_content()->AddChildView(row_view);
         item_list_changed = true;
       }
     }
 
     // Remove items from the list that haven't been added or modified with this
     // update batch.
-    std::set<FilePath> remove_set;
-    for (std::map<FilePath, RowView*>::iterator update_iter =
+    std::set<base::FilePath> remove_set;
+    for (std::map<base::FilePath, RowView*>::iterator update_iter =
              update_map_.begin();
          update_iter != update_map_.end(); ++update_iter) {
       if (new_set.find(update_iter->first) == new_set.end()) {
         remove_set.insert(update_iter->first);
       }
     }
 
-    for (std::set<FilePath>::iterator removed_iter = remove_set.begin();
+    for (std::set<base::FilePath>::iterator removed_iter = remove_set.begin();
         removed_iter != remove_set.end(); ++removed_iter)  {
       delete update_map_[*removed_iter];
       update_map_.erase(*removed_iter);
       item_list_changed = true;
     }
 
     if (item_list_changed)
       scroller()->Layout();
 
     // Close the details if there is really nothing to show there anymore.
@@ skipping 17 matching lines @@
   virtual void ClickedOn(views::View* sender) OVERRIDE {
     SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
     if (sender == footer()->content()) {
       owner()->system_tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
     } else if (sender == settings_) {
       delegate->ShowDriveSettings();
     }
   }
 
   // Maps operation entries to their file paths.
-  std::map<FilePath, RowView*> update_map_;
+  std::map<base::FilePath, RowView*> update_map_;
   views::View* settings_;
   gfx::ImageSkia* in_progress_img_;
   gfx::ImageSkia* done_img_;
   gfx::ImageSkia* failed_img_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveDetailedView);
 };
 
 }  // namespace tray
 
@@ skipping 89 matching lines @@
 
   tray_view()->SetVisible(false);
   if (default_)
     default_->Update(&empty_list);
   if (detailed_)
     detailed_->Update(&empty_list);
 }
 
 }  // namespace internal
 }  // namespace ash