base: Remove stub scoped_variant_win.h file.

chrome_frame/test/ie_event_sink.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/ie_event_sink.h"
 
 #include "base/scoped_handle.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_variant.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::ScopedBstr;
-using base::win::ScopedVariant;
 
 namespace chrome_frame_test {
 
 const int kDefaultWaitForIEToTerminateMs = 10 * 1000;
 
 _ATL_FUNC_INFO IEEventSink::kNavigateErrorInfo = {
   CC_STDCALL, VT_EMPTY, 5, {
     VT_DISPATCH,
     VT_VARIANT | VT_BYREF,
     VT_VARIANT | VT_BYREF,
@@ skipping 145 matching lines @@
       chrome_frame.QueryFrom(doc);
       return chrome_frame.get();
     }
   }
   return false;
 }
 
 void IEEventSink::PostMessageToCF(const std::wstring& message,
                                   const std::wstring& target) {
   ScopedBstr message_bstr(message.c_str());
-  ScopedVariant target_variant(target.c_str());
+  base::win::ScopedVariant target_variant(target.c_str());
   EXPECT_HRESULT_SUCCEEDED(
       chrome_frame_->postMessage(message_bstr, target_variant));
 }
 
 void IEEventSink::SetFocusToRenderer() {
   simulate_input::SetKeyboardFocusToWindow(GetRendererWindow());
 }
 
 void IEEventSink::SendKeys(const wchar_t* input_string) {
   SetFocusToRenderer();
@@ skipping 134 matching lines @@
   HRESULT hr = LaunchIEAsComServer(web_browser2_.Receive());
   if (SUCCEEDED(hr)) {
     web_browser2_->put_Visible(VARIANT_TRUE);
     Attach(web_browser2_);
     hr = Navigate(navigate_url);
   }
   return hr;
 }
 
 HRESULT IEEventSink::Navigate(const std::wstring& navigate_url) {
-  VARIANT empty = ScopedVariant::kEmptyVariant;
-  ScopedVariant url;
+  VARIANT empty = base::win::ScopedVariant::kEmptyVariant;
+  base::win::ScopedVariant url;
   url.Set(navigate_url.c_str());
 
   HRESULT hr = S_OK;
   hr = web_browser2_->Navigate2(url.AsInput(), &empty, &empty, &empty, &empty);
   EXPECT_TRUE(hr == S_OK);
   return hr;
 }
 
 HRESULT IEEventSink::CloseWebBrowser() {
   if (!web_browser2_)
     return E_FAIL;
 
   DisconnectFromChromeFrame();
   EXPECT_HRESULT_SUCCEEDED(web_browser2_->Quit());
   return S_OK;
 }
 
 void IEEventSink::Refresh() {
-  ScopedVariant refresh_level(REFRESH_NORMAL);
+  base::win::ScopedVariant refresh_level(REFRESH_NORMAL);
   web_browser2_->Refresh2(refresh_level.AsInput());
 }
 
 // private methods
 void IEEventSink::ConnectToChromeFrame() {
   DCHECK(web_browser2_);
   if (chrome_frame_.get())
     return;
   ScopedComPtr<IShellBrowser> shell_browser;
   DoQueryService(SID_STopLevelBrowser, web_browser2_,
                  shell_browser.Receive());
 
   if (shell_browser) {
     ScopedComPtr<IShellView> shell_view;
     shell_browser->QueryActiveShellView(shell_view.Receive());
     if (shell_view) {
       shell_view->GetItemObject(SVGIO_BACKGROUND, __uuidof(IChromeFrame),
            reinterpret_cast<void**>(chrome_frame_.Receive()));
     }
 
     if (chrome_frame_) {
-      ScopedVariant onmessage(onmessage_.ToDispatch());
-      ScopedVariant onloaderror(onloaderror_.ToDispatch());
-      ScopedVariant onload(onload_.ToDispatch());
+      base::win::ScopedVariant onmessage(onmessage_.ToDispatch());
+      base::win::ScopedVariant onloaderror(onloaderror_.ToDispatch());
+      base::win::ScopedVariant onload(onload_.ToDispatch());
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onmessage(onmessage));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onloaderror(onloaderror));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onload(onload));
     }
   }
 }
 
 void IEEventSink::DisconnectFromChromeFrame() {
   if (chrome_frame_) {
     // Use a local ref counted copy of the IChromeFrame interface as the
     // outgoing calls could cause the interface to be deleted due to a message
     // pump running in the context of the outgoing call.
     ScopedComPtr<IChromeFrame> chrome_frame(chrome_frame_);
     chrome_frame_.Release();
-    ScopedVariant dummy(static_cast<IDispatch*>(NULL));
+    base::win::ScopedVariant dummy(static_cast<IDispatch*>(NULL));
     chrome_frame->put_onmessage(dummy);
     chrome_frame->put_onload(dummy);
     chrome_frame->put_onloaderror(dummy);
   }
 }
 
 void IEEventSink::FindIEProcessId() {
   HWND hwnd = NULL;
   web_browser2_->get_HWND(reinterpret_cast<SHANDLE_PTR*>(&hwnd));
   EXPECT_TRUE(::IsWindow(hwnd));
@@ skipping 99 matching lines @@
 
   DispEventUnadvise(web_browser2_);
   CoDisconnectObject(this, 0);
 
   if (listener_)
     listener_->OnQuit();
 }
 
 HRESULT IEEventSink::OnLoad(const VARIANT* param) {
   DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
-  ScopedVariant stack_object(*param);
+  base::win::ScopedVariant stack_object(*param);
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoad(param->bstrVal);
   } else {
     DLOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnLoadError(const VARIANT* param) {
   DVLOG(1) << __FUNCTION__ << " " << param->bstrVal;
   if (chrome_frame_) {
     if (listener_)
       listener_->OnLoadError(param->bstrVal);
   } else {
     DLOG(WARNING) << "Invalid chrome frame pointer";
   }
   return S_OK;
 }
 
 HRESULT IEEventSink::OnMessage(const VARIANT* param) {
   DVLOG(1) << __FUNCTION__ << " " << param;
   if (!chrome_frame_.get()) {
     DLOG(WARNING) << "Invalid chrome frame pointer";
     return S_OK;
   }
 
-  ScopedVariant data, origin, source;
+  base::win::ScopedVariant data, origin, source;
   if (param && (V_VT(param) == VT_DISPATCH)) {
     wchar_t* properties[] = { L"data", L"origin", L"source" };
     const int prop_count = arraysize(properties);
     DISPID ids[prop_count] = {0};
 
     HRESULT hr = param->pdispVal->GetIDsOfNames(IID_NULL, properties,
         prop_count, LOCALE_SYSTEM_DEFAULT, ids);
     if (SUCCEEDED(hr)) {
       DISPPARAMS params = { 0 };
       EXPECT_HRESULT_SUCCEEDED(param->pdispVal->Invoke(ids[0], IID_NULL,
           LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &params,
           data.Receive(), NULL, NULL));
       EXPECT_HRESULT_SUCCEEDED(param->pdispVal->Invoke(ids[1], IID_NULL,
           LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &params,
           origin.Receive(), NULL, NULL));
       EXPECT_HRESULT_SUCCEEDED(param->pdispVal->Invoke(ids[2], IID_NULL,
           LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &params,
           source.Receive(), NULL, NULL));
     }
   }
 
   if (listener_)
     listener_->OnMessage(V_BSTR(&data), V_BSTR(&origin), V_BSTR(&source));
   return S_OK;
 }
 
 }  // namespace chrome_frame_test