Remove redirection header and add "ui::" before all SelectFileDialog usage.

chrome/browser/extensions/api/file_system/file_system_api.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 "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 241 matching lines @@
   bool is_writable = policy->CanReadWriteFileSystem(renderer_id,
                                                     filesystem_id);
 
   SetResult(base::Value::CreateBooleanValue(is_writable));
   return true;
 }
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
 class FileSystemChooseFileFunction::FilePicker
-    : public SelectFileDialog::Listener {
+    : public ui::SelectFileDialog::Listener {
  public:
   FilePicker(FileSystemChooseFileFunction* function,
              content::WebContents* web_contents,
              const FilePath& suggested_name,
-             SelectFileDialog::Type picker_type,
+             ui::SelectFileDialog::Type picker_type,
              EntryType entry_type)
       : suggested_name_(suggested_name),
         entry_type_(entry_type),
         function_(function) {
-    select_file_dialog_ = SelectFileDialog::Create(
+    select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(web_contents));
-    SelectFileDialog::FileTypeInfo file_type_info;
+    ui::SelectFileDialog::FileTypeInfo file_type_info;
     FilePath::StringType extension = suggested_name.Extension();
     if (!extension.empty()) {
       extension.erase(extension.begin());  // drop the .
       file_type_info.extensions.resize(1);
       file_type_info.extensions[0].push_back(extension);
     }
     file_type_info.include_all_files = true;
     gfx::NativeWindow owning_window = web_contents ?
         platform_util::GetTopLevel(web_contents->GetNativeView()) : NULL;
 
@@ skipping 34 matching lines @@
 
   virtual void FileSelectionCanceled(void* params) OVERRIDE {
     function_->FileSelectionCanceled();
     delete this;
   }
 
   FilePath suggested_name_;
 
   EntryType entry_type_;
 
-  scoped_refptr<SelectFileDialog> select_file_dialog_;
+  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
   scoped_refptr<FileSystemChooseFileFunction> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePicker);
 };
 
 bool FileSystemChooseFileFunction::ShowPicker(
     const FilePath& suggested_name,
-    SelectFileDialog::Type picker_type,
+    ui::SelectFileDialog::Type picker_type,
     EntryType entry_type) {
   ShellWindowRegistry* registry = ShellWindowRegistry::Get(profile());
   DCHECK(registry);
   ShellWindow* shell_window = registry->GetShellWindowForRenderViewHost(
       render_view_host());
   if (!shell_window) {
     error_ = kInvalidCallingPage;
     return false;
   }
 
@@ skipping 41 matching lines @@
   error_ = kUserCancelled;
   SendResponse(false);
 }
 
 bool FileSystemChooseFileFunction::RunImpl() {
   scoped_ptr<ChooseFile::Params> params(ChooseFile::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   FilePath suggested_name;
   EntryType entry_type = READ_ONLY;
-  SelectFileDialog::Type picker_type = SelectFileDialog::SELECT_OPEN_FILE;
+  ui::SelectFileDialog::Type picker_type =
+      ui::SelectFileDialog::SELECT_OPEN_FILE;
 
   file_system::ChooseFileOptions* options = params->options.get();
   if (options) {
     if (options->type.get()) {
       if (*options->type == kOpenWritableFileOption) {
         entry_type = WRITABLE;
       } else if (*options->type == kSaveFileOption) {
         entry_type = WRITABLE;
-        picker_type = SelectFileDialog::SELECT_SAVEAS_FILE;
+        picker_type = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
       } else if (*options->type != kOpenFileOption) {
         error_ = kUnknownChooseFileType;
         return false;
       }
     }
 
     if (options->suggested_name.get()) {
       suggested_name = FilePath::FromUTF8Unsafe(
           *options->suggested_name.get());
 
       // Don't allow any path components; shorten to the base name. This should
       // result in a relative path, but in some cases may not. Clear the
       // suggestion for safety if this is the case.
       suggested_name = suggested_name.BaseName();
       if (suggested_name.IsAbsolute()) {
         suggested_name = FilePath();
       }
     }
   }
 
   if (entry_type == WRITABLE && !HasFileSystemWritePermission()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   return ShowPicker(suggested_name, picker_type, entry_type);
 }
 
 }  // namespace extensions