Added support for displaying the select folder picker in Chrome ASH on Windows 8.

ui/aura/remote_root_window_host_win.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/aura/remote_root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
@@ skipping 75 matching lines @@
     const SaveFileCompletion& callback) {
   DCHECK(aura::RemoteRootWindowHostWin::Instance());
   aura::RemoteRootWindowHostWin::Instance()->HandleSaveFile(title,
                                                             default_path,
                                                             filter,
                                                             filter_index,
                                                             default_extension,
                                                             callback);
 }
 
+void HandleSelectFolder(const string16& title,
+                        const SelectFolderCompletion& callback) {
+  DCHECK(aura::RemoteRootWindowHostWin::Instance());
+  aura::RemoteRootWindowHostWin::Instance()->HandleSelectFolder(title,
+                                                                callback);
+}
+
 RemoteRootWindowHostWin* g_instance = NULL;
 
 RemoteRootWindowHostWin* RemoteRootWindowHostWin::Instance() {
   return g_instance;
 }
 
 RemoteRootWindowHostWin* RemoteRootWindowHostWin::Create(
     const gfx::Rect& bounds) {
   g_instance = new RemoteRootWindowHostWin(bounds);
   return g_instance;
@@ skipping 32 matching lines @@
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchUp,
                         OnTouchUp)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_TouchMoved,
                         OnTouchMoved)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_FileSaveAsDone,
                         OnFileSaveAsDone)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_FileOpenDone,
                         OnFileOpenDone)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MultiFileOpenDone,
                         OnMultiFileOpenDone)
+    IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SelectFolderDone,
+                        OnSelectFolderDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RemoteRootWindowHostWin::HandleOpenFile(
     const string16& title,
     const base::FilePath& default_path,
     const string16& filter,
     const OpenFileCompletion& callback) {
   if (!host_)
     return;
 
-  // Can only one of these operations in flight.
+  // Can only have one of these operations in flight.
   DCHECK(file_open_completion_callback_.is_null());
   file_open_completion_callback_ = callback;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileOpen(title,
                                                      filter,
-                                                     default_path.value(),
+                                                     default_path,
                                                      false));
 }
 
 void RemoteRootWindowHostWin::HandleOpenMultipleFiles(
       const string16& title,
       const base::FilePath& default_path,
       const string16& filter,
       const OpenMultipleFilesCompletion& callback) {
   if (!host_)
     return;
 
-  // Can only one of these operations in flight.
+  // Can only have one of these operations in flight.
   DCHECK(multi_file_open_completion_callback_.is_null());
   multi_file_open_completion_callback_ = callback;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileOpen(title,
                                                      filter,
-                                                     default_path.value(),
+                                                     default_path,
                                                      true));
 }
 
 void RemoteRootWindowHostWin::HandleSaveFile(
     const string16& title,
     const base::FilePath& default_path,
     const string16& filter,
     int filter_index,
     const string16& default_extension,
     const SaveFileCompletion& callback) {
   if (!host_)
     return;
 
   MetroViewerHostMsg_SaveAsDialogParams params;
   params.title = title;
   params.default_extension = default_extension;
   params.filter = filter;
   params.filter_index = filter_index;
 
-  // Can only one of these operations in flight.
+  // Can only have one of these operations in flight.
   DCHECK(file_saveas_completion_callback_.is_null());
   file_saveas_completion_callback_ = callback;
 
   host_->Send(new MetroViewerHostMsg_DisplayFileSaveAs(params));
 }
 
+void RemoteRootWindowHostWin::HandleSelectFolder(
+    const string16& title,
+    const SelectFolderCompletion& callback) {
+  if (!host_)
+    return;
+
+  // Can only have one of these operations in flight.
+  DCHECK(select_folder_completion_callback_.is_null());
+  select_folder_completion_callback_ = callback;
+
+  host_->Send(new MetroViewerHostMsg_DisplaySelectFolder(title));
+}
+
 void RemoteRootWindowHostWin::SetDelegate(RootWindowHostDelegate* delegate) {
   delegate_ = delegate;
 }
 
 RootWindow* RemoteRootWindowHostWin::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
 gfx::AcceleratedWidget RemoteRootWindowHostWin::GetAcceleratedWidget() {
   // TODO(cpu): This is bad. Chrome's compositor needs a valid window
@@ skipping 175 matching lines @@
                                            uint64 timestamp,
                                            uint32 pointer_id) {
   ui::TouchEvent event(ui::ET_TOUCH_MOVED,
                        gfx::Point(x, y),
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
   delegate_->OnHostTouchEvent(&event);
 }
 
 void RemoteRootWindowHostWin::OnFileSaveAsDone(bool success,
-                                               string16 filename,
+                                               const base::FilePath& filename,
                                                int filter_index) {
   if (success) {
-    file_saveas_completion_callback_.Run(
-        base::FilePath(filename), filter_index, NULL);
+    file_saveas_completion_callback_.Run(filename, filter_index, NULL);
   }
   file_saveas_completion_callback_.Reset();
 }
 
 
-void RemoteRootWindowHostWin::OnFileOpenDone(bool success, string16 filename) {
+void RemoteRootWindowHostWin::OnFileOpenDone(bool success,
+                                             const base::FilePath& filename) {
   if (success) {
     file_open_completion_callback_.Run(
         base::FilePath(filename), 0, NULL);
   }
   file_open_completion_callback_.Reset();
 }
 
 void RemoteRootWindowHostWin::OnMultiFileOpenDone(
     bool success,
     const std::vector<base::FilePath>& files) {
   if (success) {
     multi_file_open_completion_callback_.Run(files, NULL);
   }
   multi_file_open_completion_callback_.Reset();
 }
 
+void RemoteRootWindowHostWin::OnSelectFolderDone(
+    bool success,
+    const base::FilePath& folder) {
+  if (success) {
+    select_folder_completion_callback_.Run(base::FilePath(folder), 0, NULL);
+  }
+  select_folder_completion_callback_.Reset();
+}
+
 void RemoteRootWindowHostWin::DispatchKeyboardMessage(ui::EventType type,
                                                       uint32 vkey,
                                                       uint32 repeat_count,
                                                       uint32 scan_code,
                                                       uint32 flags,
                                                       bool is_character) {
   if (MessageLoop::current()->IsNested()) {
     SetVirtualKeyStates(flags);
 
     uint32 message = is_character ? WM_CHAR :
         (type == ui::ET_KEY_PRESSED ? WM_KEYDOWN : WM_KEYUP);
     ::PostThreadMessage(::GetCurrentThreadId(),
                         message,
                         vkey,
                         repeat_count | scan_code >> 15);
   } else {
     ui::KeyEvent event(type,
                        ui::KeyboardCodeForWindowsKeyCode(vkey),
                        flags,
                        is_character);
     delegate_->OnHostKeyEvent(&event);
   }
 }
 
 }  // namespace aura