Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

chrome_frame/test/chrome_frame_ui_test_utils.cc

 // Copyright (c) 2011 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 19 matching lines @@
 const int kChromeDOMAccessibilityTreeTimeoutMs = 10 * 1000;
 
 // Timeout for waiting on a menu to popup.
 const int kMenuPopupTimeoutMs = 10 * 1000;
 
 // AccObject methods
 AccObject::AccObject(IAccessible* accessible, int child_id)
     : accessible_(accessible), child_id_(child_id) {
   DCHECK(accessible);
   if (child_id != CHILDID_SELF) {
-    ScopedComPtr<IDispatch> dispatch;
+    base::win::ScopedComPtr<IDispatch> dispatch;
     // This class does not support referring to a full MSAA object using the
     // parent object and the child id.
     HRESULT result = accessible_->get_accChild(child_id_, dispatch.Receive());
     if (result != S_FALSE && result != E_NOINTERFACE) {
       LOG(ERROR) << "AccObject created which refers to full MSAA object using "
                     "parent object and child id. This should NOT be done.";
     }
     DCHECK(result == S_FALSE || result == E_NOINTERFACE);
   }
 }
 
 // static
 AccObject* AccObject::CreateFromWindow(HWND hwnd) {
-  ScopedComPtr<IAccessible> accessible;
+  base::win::ScopedComPtr<IAccessible> accessible;
   ::AccessibleObjectFromWindow(hwnd, OBJID_CLIENT,
       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;
+  base::win::ScopedComPtr<IAccessible> accessible;
   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;
+    base::win::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;
+  base::win::ScopedComPtr<IAccessible> accessible;
   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
@@ skipping 148 matching lines @@
     return false;
   }
   location.Offset(offset.x, offset.y);
   *client_location = location;
   return true;
 }
 
 AccObject* AccObject::GetParent() {
   if (IsSimpleElement())
     return new AccObject(accessible_);
-  ScopedComPtr<IDispatch> dispatch;
+  base::win::ScopedComPtr<IDispatch> dispatch;
   if (FAILED(accessible_->get_accParent(dispatch.Receive())))
     return NULL;
   return AccObject::CreateFromDispatch(dispatch.get());
 }
 
 bool AccObject::GetChildren(RefCountedAccObjectVector* client_objects) {
   DCHECK(client_objects);
   int child_count;
   if (!GetChildCount(&child_count)) {
     LOG(ERROR) << "Failed to get child count of AccObject";
@@ skipping 114 matching lines @@
       *class_name = class_arr;
       return true;
     }
   }
   return false;
 }
 
 bool AccObject::GetSelectionRange(int* start_offset, int* end_offset) {
   DCHECK(start_offset);
   DCHECK(end_offset);
-  ScopedComPtr<IAccessibleText> accessible_text;
+  base::win::ScopedComPtr<IAccessibleText> accessible_text;
   HRESULT hr = DoQueryService(IID_IAccessibleText,
                               accessible_,
                               accessible_text.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Could not get IAccessibleText interface. Error: " << hr
                << "\nIs IAccessible2Proxy.dll registered?";
     return false;
   }
 
   LONG selection_count = 0;
   accessible_text->get_nSelections(&selection_count);
   LONG start = 0, end = 0;
   if (selection_count > 0) {
     if (FAILED(accessible_text->get_selection(0, &start, &end))) {
       LOG(WARNING) << "Could not get first selection";
       return false;
     }
   }
   *start_offset = start;
   *end_offset = end;
   return true;
 }
 
 bool AccObject::GetSelectedText(std::wstring* text) {
   DCHECK(text);
   int start = 0, end = 0;
   if (!GetSelectionRange(&start, &end))
     return false;
-  ScopedComPtr<IAccessibleText> accessible_text;
+  base::win::ScopedComPtr<IAccessibleText> accessible_text;
   HRESULT hr = DoQueryService(IID_IAccessibleText,
                               accessible_,
                               accessible_text.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Could not get IAccessibleText interface. Error: " << hr
                << "\nIs IAccessible2Proxy.dll registered?";
     return false;
   }
   base::win::ScopedBstr text_bstr;
   if (FAILED(accessible_text->get_text(start, end, text_bstr.Receive()))) {
@@ skipping 61 matching lines @@
                                         const VARIANT& variant) {
   IAccessible* accessible = object->accessible_;
   if (V_VT(&variant) == VT_I4) {
     // According to MSDN, a server is allowed to return a full Accessibility
     // object using the parent object and the child id. If get_accChild is
     // called with the id, the server must return the actual IAccessible
     // interface. Do that here to get an actual IAccessible interface if
     // possible, since this class operates under the assumption that if the
     // child id is not CHILDID_SELF, the object is a simple element. See the
     // DCHECK in the constructor.
-    ScopedComPtr<IDispatch> dispatch;
+    base::win::ScopedComPtr<IDispatch> dispatch;
     HRESULT result = accessible->get_accChild(variant,
                                               dispatch.Receive());
     if (result == S_FALSE || result == E_NOINTERFACE) {
       // The object in question really is a simple element.
       return new AccObject(accessible, V_I4(&variant));
     } else if (SUCCEEDED(result)) {
       // The object in question was actually a full object.
       return CreateFromDispatch(dispatch.get());
     }
     VLOG(1) << "Failed to determine if child id refers to a full "
@@ skipping 225 matching lines @@
   return desk;
 }
 
 FilePath GetIAccessible2ProxyStubPath() {
   FilePath path;
   PathService::Get(chrome::DIR_APP, &path);
   return path.AppendASCII("IAccessible2Proxy.dll");
 }
 
 }  // namespace chrome_frame_test