base: Remove operator& from ScopedVariant and ScopedPropVariant.

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 297 matching lines @@
   HRESULT hr = S_OK;
   base::win::ScopedVariant var;
 
   hr = window->GetCachedPropertyValueEx(UIA_ClassNamePropertyId, TRUE,
                                         var.Receive());
   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);
+  if (V_VT(var.ptr()) != VT_BSTR) {
+    LOG(ERROR) << __FUNCTION__
+               << " class name is not a BSTR: " << V_VT(var.ptr());
     return;
   }
 
-  base::string16 class_name(V_BSTR(&var));
+  base::string16 class_name(V_BSTR(var.ptr()));
 
   // 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);
   }
 }
 
@@ skipping 192 matching lines @@
     if (FAILED(result)) {
       LOG(ERROR) << std::hex << result;
       continue;
     }
     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);
+    if (V_VT(var.ptr()) != VT_BSTR) {
+      LOG(ERROR) << __FUNCTION__ << " name is not a BSTR: " << V_VT(var.ptr());
       continue;
     }
-    choices->push_back(base::string16(V_BSTR(&var)));
+    choices->push_back(base::string16(V_BSTR(var.ptr())));
     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());
 
   // It's tempting to get the Window pattern from |window| and invoke its Close
   // method. Unfortunately, this doesn't work. Sending an escape key does the
   // trick, though.
   HRESULT result = S_OK;
   base::win::ScopedVariant var;
 
   result = window->GetCachedPropertyValueEx(
       UIA_NativeWindowHandlePropertyId,
       TRUE,
       var.Receive());
   if (FAILED(result)) {
     LOG(ERROR) << std::hex << result;
     return;
   }
 
-  if (V_VT(&var) != VT_I4) {
+  if (V_VT(var.ptr()) != VT_I4) {
     LOG(ERROR) << __FUNCTION__
-               << " window handle is not an int: " << V_VT(&var);
+               << " window handle is not an int: " << V_VT(var.ptr());
     return;
   }
 
-  HWND handle = reinterpret_cast<HWND>(V_I4(&var));
+  HWND handle = reinterpret_cast<HWND>(V_I4(var.ptr()));
 
   uint32 scan_code = MapVirtualKey(VK_ESCAPE, MAPVK_VK_TO_VSC);
   PostMessage(handle, WM_KEYDOWN, VK_ESCAPE,
               MAKELPARAM(1, scan_code));
   PostMessage(handle, WM_KEYUP, VK_ESCAPE,
               MAKELPARAM(1, scan_code | KF_REPEAT | KF_UP));
 }
 
 UIAutomationClient::UIAutomationClient()
     : automation_thread_("UIAutomation") {}
@@ skipping 27 matching lines @@
                  context_,
                  base::ThreadTaskRunnerHandle::Get(),
                  base::string16(class_name),
                  item_name,
                  init_callback,
                  result_callback));
 }
 
 }  // namespace internal
 }  // namespace win8