base: Remove stub scoped_variant_win.h file.

chrome_frame/test/chrome_frame_ui_test_utils.cc

 // Copyright (c) 2010 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 "chrome_frame/test/chrome_frame_ui_test_utils.h"
 
 #include <windows.h>
 
 #include <sstream>
 #include <stack>
@@ skipping 42 matching lines @@
       IID_IAccessible, reinterpret_cast<void**>(accessible.Receive()));
   if (accessible)
     return new AccObject(accessible);
   return NULL;
 }
 
 // static
 AccObject* AccObject::CreateFromEvent(HWND hwnd, LONG object_id,
                                       LONG child_id) {
   ScopedComPtr<IAccessible> accessible;
-  ScopedVariant acc_child_id;
+  base::win::ScopedVariant acc_child_id;
   ::AccessibleObjectFromEvent(hwnd, object_id, child_id, accessible.Receive(),
                               acc_child_id.Receive());
   if (accessible && acc_child_id.type() == VT_I4)
     return new AccObject(accessible, V_I4(&acc_child_id));
   return NULL;
 }
 
 // static
 AccObject* AccObject::CreateFromDispatch(IDispatch* dispatch) {
   if (dispatch) {
     ScopedComPtr<IAccessible> accessible;
     accessible.QueryFrom(dispatch);
     if (accessible)
       return new AccObject(accessible);
   }
   return NULL;
 }
 
 // static
 AccObject* AccObject::CreateFromPoint(int x, int y) {
   ScopedComPtr<IAccessible> accessible;
-  ScopedVariant child_id;
+  base::win::ScopedVariant child_id;
   POINT point = {x, y};
   ::AccessibleObjectFromPoint(point, accessible.Receive(), child_id.Receive());
   if (accessible && child_id.type() == VT_I4)
     return new AccObject(accessible, V_I4(&child_id));
   return NULL;
 }
 
 bool AccObject::DoDefaultAction() {
   // Prevent clients from using this method to try to select menu items, which
   // does not work with a locked desktop.
@@ skipping 16 matching lines @@
   return PostMouseButtonMessages(WM_RBUTTONDOWN, WM_RBUTTONUP);
 }
 
 bool AccObject::Focus() {
   EXPECT_HRESULT_SUCCEEDED(
       accessible_->accSelect(SELFLAG_TAKEFOCUS, child_id_));
 
   // Double check that the object actually received focus. In some cases
   // the parent object must have the focus first.
   bool did_focus = false;
-  ScopedVariant focused;
+  base::win::ScopedVariant focused;
   if (SUCCEEDED(accessible_->get_accFocus(focused.Receive()))) {
     if (focused.type() != VT_EMPTY)
       did_focus = true;
   }
   EXPECT_TRUE(did_focus) << "Could not focus AccObject: " << GetDescription();
   return did_focus;
 }
 
 bool AccObject::Select() {
   // SELFLAG_TAKESELECTION needs to be combined with the focus in order to
   // take effect.
   int selection_flag = SELFLAG_TAKEFOCUS | SELFLAG_TAKESELECTION;
   EXPECT_HRESULT_SUCCEEDED(accessible_->accSelect(selection_flag, child_id_));
 
   // Double check that the object actually received selection.
   bool did_select = false;
-  ScopedVariant selected;
+  base::win::ScopedVariant selected;
   if (SUCCEEDED(accessible_->get_accSelection(selected.Receive()))) {
     if (selected.type() != VT_EMPTY)
       did_select = true;
   }
   EXPECT_TRUE(did_select) << "Could not select AccObject: " << GetDescription();
   return did_select;
 }
 
 bool AccObject::SetValue(const std::wstring& value) {
   base::win::ScopedBstr value_bstr(value.c_str());
@@ skipping 15 matching lines @@
   DCHECK(name);
   base::win::ScopedBstr name_bstr;
   HRESULT result = accessible_->get_accName(child_id_, name_bstr.Receive());
   if (SUCCEEDED(result))
     name->assign(name_bstr, name_bstr.Length());
   return SUCCEEDED(result);
 }
 
 bool AccObject::GetRoleText(std::wstring* role_text) {
   DCHECK(role_text);
-  ScopedVariant role_variant;
+  base::win::ScopedVariant role_variant;
   if (SUCCEEDED(accessible_->get_accRole(child_id_, role_variant.Receive()))) {
     if (role_variant.type() == VT_I4) {
       wchar_t role_text_array[50];
       UINT characters = ::GetRoleText(V_I4(&role_variant), role_text_array,
                                       arraysize(role_text_array));
       if (characters) {
         *role_text = role_text_array;
         return true;
       } else {
         DLOG(ERROR) << "GetRoleText failed for role: "
@@ skipping 14 matching lines @@
   DCHECK(value);
   base::win::ScopedBstr value_bstr;
   HRESULT result = accessible_->get_accValue(child_id_, value_bstr.Receive());
   if (SUCCEEDED(result))
     value->assign(value_bstr, value_bstr.Length());
   return SUCCEEDED(result);
 }
 
 bool AccObject::GetState(int* state) {
   DCHECK(state);
-  ScopedVariant state_variant;
+  base::win::ScopedVariant state_variant;
   if (SUCCEEDED(accessible_->get_accState(child_id_,
                                           state_variant.Receive()))) {
     if (state_variant.type() == VT_I4) {
       *state = V_I4(&state_variant);
       return true;
     }
   }
   return false;
 }
 
@@ skipping 106 matching lines @@
   }
   return true;
 }
 
 bool AccObject::GetFromNavigation(long navigation_type,
                                   scoped_refptr<AccObject>* object) {
   DCHECK(object);
   bool is_child_navigation = navigation_type == NAVDIR_FIRSTCHILD ||
                              navigation_type == NAVDIR_LASTCHILD;
   DCHECK(!is_child_navigation || !IsSimpleElement());
-  ScopedVariant object_variant;
+  base::win::ScopedVariant object_variant;
   HRESULT result = accessible_->accNavigate(navigation_type,
                                             child_id_,
                                             object_variant.Receive());
   if (FAILED(result)) {
     LOG(WARNING) << "Navigation from accessibility object failed";
     return false;
   }
   if (result == S_FALSE || object_variant.type() == VT_EMPTY) {
     // This indicates that there was no accessibility object found by the
     // navigation.
@@ skipping 316 matching lines @@
 }
 
 bool IsDesktopUnlocked() {
   HDESK desk = ::OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP);
   if (desk)
     ::CloseDesktop(desk);
   return desk;
 }
 
 }  // namespace chrome_frame_test