Add base:: to string16s in win8/.

win8/metro_driver/file_picker.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 "stdafx.h"
 #include "win8/metro_driver/file_picker.h"
 
 #include <windows.storage.pickers.h>
 
 #include "base/bind.h"
@@ skipping 12 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 81 matching lines @@
 
   // Called asynchronously when a single file picker is done.
   HRESULT SinglePickerDone(SingleFileAsyncOp* async, AsyncStatus status);
 
   // Called asynchronously when a multi file picker is done.
   HRESULT MultiPickerDone(MultiFileAsyncOp* async, AsyncStatus status);
 
   // Composes a multi-file result string suitable for returning to a
   // from a storage file collection.
   static HRESULT ComposeMultiFileResult(StorageFileVectorCollection* files,
-                                        string16* result);
+                                        base::string16* result);
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenFilePickerSession);
 };
 
 class SaveFilePickerSession : public FilePickerSessionBase {
  public:
   explicit SaveFilePickerSession(OPENFILENAME* open_file_name);
 
  private:
   virtual HRESULT StartFilePicker() OVERRIDE;
@@ skipping 90 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)) {
         if (result.size() + 1 < open_file_name_->nMaxFile) {
           // Because the result has embedded nulls, we must memcpy.
           memcpy(open_file_name_->lpstrFile,
                  result.c_str(),
                  (result.size() + 1) * sizeof(result[0]));
           success_ = true;
@@ skipping 41 matching lines @@
     const wchar_t* walk = open_file_name_->lpstrFilter;
     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 83 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);
   }
 
@@ skipping 30 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());
 
         // If the selected file name is longer than the supplied buffer,
         // we return false as per GetOpenFileName documentation.
         if (path_str.size() < open_file_name_->nMaxFile) {
           base::wcslcpy(open_file_name_->lpstrFile,
                         path_str.c_str(),
                         open_file_name_->nMaxFile);
           success_ = true;
         }
       }
@@ skipping 15 matching lines @@
   OpenFilePickerSession session(open_file_name);
 
   return session.Run();
 }
 
 BOOL MetroGetSaveFileName(OPENFILENAME* open_file_name) {
   SaveFilePickerSession session(open_file_name);
 
   return session.Run();
 }