Add base:: to string16s in win8/.

win8/test/ui_automation_client.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 "win8/test/ui_automation_client.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <oleauto.h>
 #include <uiautomation.h>
@@ skipping 22 matching lines @@
 
   // Deletes the instance.
   void DeleteOnAutomationThread();
 
   // Initializes the context, invoking |init_callback| via |client_runner| when
   // done. On success, |result_callback| will eventually be called after the
   // window has been processed. On failure, this instance self-destructs after
   // posting |init_callback|.
   void Initialize(
       scoped_refptr<base::SingleThreadTaskRunner> client_runner,
-      string16 class_name,
-      string16 item_name,
+      base::string16 class_name,
+      base::string16 item_name,
       UIAutomationClient::InitializedCallback init_callback,
       UIAutomationClient::ResultCallback result_callback);
 
   // Methods invoked by event handlers via weak pointers.
   void HandleAutomationEvent(
       base::win::ScopedComPtr<IUIAutomationElement> sender,
       EVENTID eventId);
 
  private:
   class EventHandler;
 
   // The only and only method that may be called from outside of the automation
   // thread.
   Context();
   ~Context();
 
   HRESULT InstallWindowObserver();
   HRESULT RemoveWindowObserver();
 
   void HandleWindowOpen(
       const base::win::ScopedComPtr<IUIAutomationElement>& window);
   void ProcessWindow(
       const base::win::ScopedComPtr<IUIAutomationElement>& window);
   HRESULT InvokeDesiredItem(
       const base::win::ScopedComPtr<IUIAutomationElement>& element);
   HRESULT GetInvokableItems(
       const base::win::ScopedComPtr<IUIAutomationElement>& element,
-      std::vector<string16>* choices);
+      std::vector<base::string16>* choices);
   void CloseWindow(const base::win::ScopedComPtr<IUIAutomationElement>& window);
 
   base::ThreadChecker thread_checker_;
 
   // The loop on which the client itself lives.
   scoped_refptr<base::SingleThreadTaskRunner> client_runner_;
 
   // The class name of the window for which the client waits.
-  string16 class_name_;
+  base::string16 class_name_;
 
   // The name of the item to invoke.
-  string16 item_name_;
+  base::string16 item_name_;
 
   // The consumer's result callback.
   ResultCallback result_callback_;
 
   // The automation client.
   base::win::ScopedComPtr<IUIAutomation> automation_;
 
   // A handler of Window open events.
   base::win::ScopedComPtr<IUIAutomationEventHandler> event_handler_;
 
@@ skipping 78 matching lines @@
 
   if (event_handler_.get()) {
     event_handler_ = NULL;
     HRESULT result = automation_->RemoveAllEventHandlers();
     LOG_IF(ERROR, FAILED(result)) << std::hex << result;
   }
 }
 
 void UIAutomationClient::Context::Initialize(
     scoped_refptr<base::SingleThreadTaskRunner> client_runner,
-    string16 class_name,
-    string16 item_name,
+    base::string16 class_name,
+    base::string16 item_name,
     UIAutomationClient::InitializedCallback init_callback,
     UIAutomationClient::ResultCallback result_callback) {
   // This and all other methods must be called on the automation thread.
   DCHECK(!client_runner->BelongsToCurrentThread());
   // Bind the checker to this thread.
   thread_checker_.DetachFromThread();
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_runner_ = client_runner;
   class_name_ = class_name;
@@ skipping 123 matching lines @@
   if (FAILED(hr)) {
     LOG(ERROR) << std::hex << hr;
     return;
   }
 
   if (V_VT(&var) != VT_BSTR) {
     LOG(ERROR) << __FUNCTION__ " class name is not a BSTR: " << V_VT(&var);
     return;
   }
 
-  string16 class_name(V_BSTR(&var));
+  base::string16 class_name(V_BSTR(&var));
 
   // Window class names are atoms, which are case-insensitive.
   if (class_name.size() == class_name_.size() &&
       std::equal(class_name.begin(), class_name.end(), class_name_.begin(),
                  base::CaseInsensitiveCompare<wchar_t>())) {
     RemoveWindowObserver();
     ProcessWindow(window);
   }
 }
 
 // Processes |window| by invoking the desired child item. If the item cannot be
 // found or invoked, an attempt is made to get a list of all invokable children.
 // The results are posted back to the client on |client_runner_|, and this
 // instance self-destructs.
 void UIAutomationClient::Context::ProcessWindow(
     const base::win::ScopedComPtr<IUIAutomationElement>& window) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   HRESULT result = S_OK;
-  std::vector<string16> choices;
+  std::vector<base::string16> choices;
   result = InvokeDesiredItem(window);
   if (FAILED(result)) {
     GetInvokableItems(window, &choices);
     CloseWindow(window);
   }
 
   client_runner_->PostTask(FROM_HERE,
                            base::Bind(result_callback_, result, choices));
 
   // Self-destruct since there's nothing more to be done here.
@@ skipping 91 matching lines @@
     LOG(ERROR) << std::hex << result;
     return result;
   }
 
   return S_OK;
 }
 
 // Populates |choices| with the names of all invokable children of |element|.
 HRESULT UIAutomationClient::Context::GetInvokableItems(
     const base::win::ScopedComPtr<IUIAutomationElement>& element,
-    std::vector<string16>* choices) {
+    std::vector<base::string16>* choices) {
   DCHECK(choices);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   HRESULT result = S_OK;
   base::win::ScopedVariant var;
   base::win::ScopedComPtr<IUIAutomationCondition> invokable_condition;
   base::win::ScopedComPtr<IUIAutomationCondition> control_view_condition;
   base::win::ScopedComPtr<IUIAutomationCondition> condition;
   base::win::ScopedComPtr<IUIAutomationCacheRequest> cache_request;
   base::win::ScopedComPtr<IUIAutomationElementArray> element_array;
@@ skipping 67 matching lines @@
     result = child_element->GetCachedPropertyValueEx(UIA_NamePropertyId, TRUE,
                                                      var.Receive());
     if (FAILED(result)) {
       LOG(ERROR) << std::hex << result;
       continue;
     }
     if (V_VT(&var) != VT_BSTR) {
       LOG(ERROR) << __FUNCTION__ " name is not a BSTR: " << V_VT(&var);
       continue;
     }
-    choices->push_back(string16(V_BSTR(&var)));
+    choices->push_back(base::string16(V_BSTR(&var)));
     var.Reset();
   }
 
   return result;
 }
 
 // Closes the element |window| by sending it an escape key.
 void UIAutomationClient::Context::CloseWindow(
     const base::win::ScopedComPtr<IUIAutomationElement>& window) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 36 matching lines @@
   // context_ is still valid when the caller destroys the instance before the
   // callback(s) have fired. In this case, delete the context on the automation
   // thread before joining with it.
   automation_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&UIAutomationClient::Context::DeleteOnAutomationThread,
                  context_));
 }
 
 void UIAutomationClient::Begin(const wchar_t* class_name,
-                               const string16& item_name,
+                               const base::string16& item_name,
                                const InitializedCallback& init_callback,
                                const ResultCallback& result_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(context_.get(), static_cast<Context*>(NULL));
 
   // Start the automation thread and initialize our automation client on it.
   context_ = Context::Create();
   automation_thread_.init_com_with_mta(true);
   automation_thread_.Start();
   automation_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&UIAutomationClient::Context::Initialize,
                  context_,
                  base::ThreadTaskRunnerHandle::Get(),
-                 string16(class_name),
+                 base::string16(class_name),
                  item_name,
                  init_callback,
                  result_callback));
 }
 
 }  // namespace internal
 }  // namespace win8