Add base:: to string16s in win8/.

win8/metro_driver/file_picker_ash.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 "stdafx.h"
 #include "win8/metro_driver/file_picker_ash.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 10 matching lines @@
 namespace winstorage = ABI::Windows::Storage;
 typedef winfoundtn::Collections::IVector<HSTRING> StringVectorItf;
 
 // TODO(siggi): Complete this implementation and move it to a common place.
 class StringVectorImpl : public mswr::RuntimeClass<StringVectorItf> {
  public:
   ~StringVectorImpl() {
     std::for_each(strings_.begin(), strings_.end(), ::WindowsDeleteString);
   }
 
-  HRESULT RuntimeClassInitialize(const std::vector<string16>& list) {
+  HRESULT RuntimeClassInitialize(const std::vector<base::string16>& list) {
     for (size_t i = 0; i < list.size(); ++i)
       strings_.push_back(MakeHString(list[i]));
 
     return S_OK;
   }
 
   // IVector<HSTRING> implementation.
   STDMETHOD(GetAt)(unsigned index, HSTRING* item) {
     if (index >= strings_.size())
       return E_INVALIDARG;
@@ skipping 33 matching lines @@
     return E_NOTIMPL;
   }
 
  private:
   std::vector<HSTRING> strings_;
 };
 
 }  // namespace
 
 FilePickerSessionBase::FilePickerSessionBase(ChromeAppViewAsh* app_view,
-                                             const string16& title,
-                                             const string16& filter,
+                                             const base::string16& title,
+                                             const base::string16& filter,
                                              const base::FilePath& default_path)
     : app_view_(app_view),
       title_(title),
       filter_(filter),
       default_path_(default_path),
       success_(false) {
 }
 
 bool FilePickerSessionBase::Run() {
   if (!DoFilePicker())
@@ skipping 13 matching lines @@
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to start file picker, error 0x"
                << std::hex << hr;
     return false;
   }
   return true;
 }
 
 OpenFilePickerSession::OpenFilePickerSession(
     ChromeAppViewAsh* app_view,
-    const string16& title,
-    const string16& filter,
+    const base::string16& title,
+    const base::string16& filter,
     const base::FilePath& default_path,
     bool allow_multi_select)
     : FilePickerSessionBase(app_view, title, filter, default_path),
       allow_multi_select_(allow_multi_select) {
 }
 
 HRESULT OpenFilePickerSession::SinglePickerDone(SingleFileAsyncOp* async,
                                                 AsyncStatus status) {
   if (status == Completed) {
     mswr::ComPtr<winstorage::IStorageFile> file;
@@ skipping 26 matching lines @@
   return S_OK;
 }
 
 HRESULT OpenFilePickerSession::MultiPickerDone(MultiFileAsyncOp* async,
                                                AsyncStatus status) {
   if (status == Completed) {
     mswr::ComPtr<StorageFileVectorCollection> files;
     HRESULT hr = async->GetResults(files.GetAddressOf());
 
     if (files) {
-      string16 result;
+      base::string16 result;
       if (SUCCEEDED(hr))
         hr = ComposeMultiFileResult(files.Get(), &result);
 
       if (SUCCEEDED(hr)) {
         success_ = true;
         // The code below has been copied from the
         // SelectFileDialogImpl::RunOpenMultiFileDialog function in
         // select_file_dialog_win.cc.
         // TODO(ananta)
         // Consolidate this into a common place.
@@ skipping 57 matching lines @@
     const wchar_t* walk = filter_.c_str();
     while (*walk != L'\0') {
       // Walk past the description.
       walk += wcslen(walk) + 1;
 
       // We should have an extension, but bail on malformed filters.
       if (*walk == L'\0')
         break;
 
       // There can be a single extension, or a list of semicolon-separated ones.
-      std::vector<string16> extensions_win32_style;
+      std::vector<base::string16> extensions_win32_style;
       size_t extension_count = Tokenize(walk, L";", &extensions_win32_style);
       DCHECK_EQ(extension_count, extensions_win32_style.size());
 
       // Metro wants suffixes only, not patterns.
       mswrw::HString extension;
       for (size_t i = 0; i < extensions_win32_style.size(); ++i) {
         if (extensions_win32_style[i] == L"*.*") {
           // The wildcard filter is "*" for Metro. The string "*.*" produces
           // an "invalid parameter" error.
           hr = extension.Set(L"*");
         } else {
           // Metro wants suffixes only, not patterns.
-          string16 ext = base::FilePath(extensions_win32_style[i]).Extension();
+          base::string16 ext =
+              base::FilePath(extensions_win32_style[i]).Extension();
           if ((ext.size() < 2) ||
-              (ext.find_first_of(L"*?") != string16::npos)) {
+              (ext.find_first_of(L"*?") != base::string16::npos)) {
             continue;
           }
           hr = extension.Set(ext.c_str());
         }
         if (SUCCEEDED(hr))
           hr = filter->Append(extension.Get());
         if (FAILED(hr))
           return hr;
       }
 
@@ skipping 30 matching lines @@
     mswr::ComPtr<HandlerDoneType> handler(mswr::Callback<HandlerDoneType>(
         this, &OpenFilePickerSession::SinglePickerDone));
     DCHECK(handler.Get() != NULL);
     hr = completion->put_Completed(handler.Get());
 
     return hr;
   }
 }
 
 HRESULT OpenFilePickerSession::ComposeMultiFileResult(
-    StorageFileVectorCollection* files, string16* result) {
+    StorageFileVectorCollection* files, base::string16* result) {
   DCHECK(files != NULL);
   DCHECK(result != NULL);
 
   // Empty the output string.
   result->clear();
 
   unsigned int num_files = 0;
   HRESULT hr = files->get_Size(&num_files);
   if (FAILED(hr))
     return hr;
@@ skipping 94 matching lines @@
         return hr;
 
       // Walk past the description.
       walk += wcslen(walk) + 1;
 
       // We should have an extension, but bail on malformed filters.
       if (*walk == L'\0')
         break;
 
       // There can be a single extension, or a list of semicolon-separated ones.
-      std::vector<string16> extensions_win32_style;
+      std::vector<base::string16> extensions_win32_style;
       size_t extension_count = Tokenize(walk, L";", &extensions_win32_style);
       DCHECK_EQ(extension_count, extensions_win32_style.size());
 
       // Metro wants suffixes only, not patterns.  Also, metro does not support
       // the all files ("*") pattern in the save picker.
-      std::vector<string16> extensions;
+      std::vector<base::string16> extensions;
       for (size_t i = 0; i < extensions_win32_style.size(); ++i) {
-        string16 ext = base::FilePath(extensions_win32_style[i]).Extension();
+        base::string16 ext =
+            base::FilePath(extensions_win32_style[i]).Extension();
         if ((ext.size() < 2) ||
-            (ext.find_first_of(L"*?") != string16::npos))
+            (ext.find_first_of(L"*?") != base::string16::npos))
           continue;
         extensions.push_back(ext);
       }
 
       if (!extensions.empty()) {
         // Convert to a Metro collection class.
         mswr::ComPtr<StringVectorItf> list;
         hr = mswr::MakeAndInitialize<StringVectorImpl>(
             list.GetAddressOf(), extensions);
         if (FAILED(hr))
@@ skipping 24 matching lines @@
     // TODO(grt): Get a properly translated string.  This can't be done from
     // within metro_driver.  Consider preprocessing the filter list in Chrome
     // land to ensure it has this entry if all others are patterns.  In that
     // case, this whole block of code can be removed.
     hr = description.Set(L"Data File");
     if (FAILED(hr))
       return hr;
 
     mswr::ComPtr<StringVectorItf> list;
     hr = mswr::MakeAndInitialize<StringVectorImpl>(
-        list.GetAddressOf(), std::vector<string16>(1, L".dat"));
+        list.GetAddressOf(), std::vector<base::string16>(1, L".dat"));
     if (FAILED(hr))
       return hr;
 
     boolean replaced = FALSE;
     hr = choices->Insert(description.Get(), list.Get(), &replaced);
     if (FAILED(hr))
       return hr;
     DCHECK_EQ(FALSE, replaced);
   }
 
   if (!default_path_.empty()) {
-    string16 file_part = default_path_.BaseName().value();
+    base::string16 file_part = default_path_.BaseName().value();
     // If the suggested_name is a root directory, then don't set it as the
     // suggested name.
     if (file_part.size() == 1 && file_part[0] == L'\\')
       file_part.clear();
     hr = picker->put_SuggestedFileName(
         mswrw::HStringReference(file_part.c_str()).Get());
     if (FAILED(hr))
       return hr;
   }
 
@@ skipping 22 matching lines @@
     if (file) {
       mswr::ComPtr<winstorage::IStorageItem> storage_item;
       if (SUCCEEDED(hr))
         hr = file.As(&storage_item);
 
       mswrw::HString file_path;
       if (SUCCEEDED(hr))
         hr = storage_item->get_Path(file_path.GetAddressOf());
 
       if (SUCCEEDED(hr)) {
-        string16 path_str = MakeStdWString(file_path.Get());
+        base::string16 path_str = MakeStdWString(file_path.Get());
         result_ = path_str;
         success_ = true;
       }
     } else {
       LOG(ERROR) << "NULL IStorageItem";
     }
   } else {
     LOG(ERROR) << "Unexpected async status " << static_cast<int>(status);
   }
   app_view_->OnSaveFileCompleted(this, success_);
   return S_OK;
 }
 
 FolderPickerSession::FolderPickerSession(ChromeAppViewAsh* app_view,
-                                         const string16& title)
+                                         const base::string16& title)
     : FilePickerSessionBase(app_view, title, L"", base::FilePath()) {}
 
 HRESULT FolderPickerSession::StartFilePicker() {
   mswrw::HStringReference class_name(
       RuntimeClass_Windows_Storage_Pickers_FolderPicker);
 
   // Create the folder picker.
   mswr::ComPtr<winstorage::Pickers::IFolderPicker> picker;
   HRESULT hr = ::Windows::Foundation::ActivateInstance(
       class_name.Get(), picker.GetAddressOf());
@@ skipping 33 matching lines @@
     if (folder) {
       mswr::ComPtr<winstorage::IStorageItem> storage_item;
       if (SUCCEEDED(hr))
         hr = folder.As(&storage_item);
 
       mswrw::HString file_path;
       if (SUCCEEDED(hr))
         hr = storage_item->get_Path(file_path.GetAddressOf());
 
       if (SUCCEEDED(hr)) {
-        string16 path_str = MakeStdWString(file_path.Get());
+        base::string16 path_str = MakeStdWString(file_path.Get());
         result_ = path_str;
         success_ = true;
       }
     } else {
       LOG(ERROR) << "NULL IStorageItem";
     }
   } else {
     LOG(ERROR) << "Unexpected async status " << static_cast<int>(status);
   }
   app_view_->OnFolderPickerCompleted(this, success_);
   return S_OK;
 }