Move the windows-specific scoped_* stuff from base to base/win and in the bas...

chrome_frame/chrome_frame_activex.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/chrome_frame_activex.h"
 
 #include <wininet.h>
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
-#include "base/scoped_bstr_win.h"
 #include "base/singleton.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/trace_event.h"
 #include "base/utf_string_conversions.h"
+#include "base/win/scoped_bstr.h"
+#include "base/win/scoped_variant.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "googleurl/src/gurl.h"
 #include "chrome_frame/utils.h"
 
 namespace {
 
 // Class used to maintain a mapping from top-level windows to ChromeFrameActivex
 // instances.
@@ skipping 172 matching lines @@
   DLOG(INFO) << __FUNCTION__;
 
   if (target.compare("*") != 0) {
     bool drop = true;
 
     if (is_privileged_) {
       // Forward messages if the control is in privileged mode.
       ScopedComPtr<IDispatch> message_event;
       if (SUCCEEDED(CreateDomEvent("message", message, origin,
                                    message_event.Receive()))) {
-        ScopedBstr target_bstr(UTF8ToWide(target).c_str());
+        base::win::ScopedBstr target_bstr(UTF8ToWide(target).c_str());
         Fire_onprivatemessage(message_event, target_bstr);
 
         FireEvent(onprivatemessage_, message_event, target_bstr);
       }
     } else {
       if (HaveSameOrigin(target, document_url_)) {
         drop = false;
       } else {
         DLOG(WARNING) << "Dropping posted message since target doesn't match "
             "the current document's origin. target=" << target;
       }
     }
 
     if (drop)
       return;
   }
 
   ScopedComPtr<IDispatch> message_event;
   if (SUCCEEDED(CreateDomEvent("message", message, origin,
                                message_event.Receive()))) {
     Fire_onmessage(message_event);
 
     FireEvent(onmessage_, message_event);
 
-    ScopedVariant event_var;
+    base::win::ScopedVariant event_var;
     event_var.Set(static_cast<IDispatch*>(message_event));
     InvokeScriptFunction(onmessage_handler_, event_var.AsInput());
   }
 }
 
 void ChromeFrameActivex::OnAutomationServerLaunchFailed(
     AutomationLaunchResult reason, const std::string& server_version) {
   Base::OnAutomationServerLaunchFailed(reason, server_version);
 
   if (reason == AUTOMATION_VERSION_MISMATCH) {
     DisplayVersionMismatchWarning(m_hWnd, server_version);
   }
 }
 
 void ChromeFrameActivex::OnExtensionInstalled(
     const FilePath& path,
     void* user_data,
     AutomationMsg_ExtensionResponseValues response) {
-  ScopedBstr path_str(path.value().c_str());
+  base::win::ScopedBstr path_str(path.value().c_str());
   Fire_onextensionready(path_str, response);
 }
 
 void ChromeFrameActivex::OnGetEnabledExtensionsComplete(
     void* user_data,
     const std::vector<FilePath>& extension_directories) {
   SAFEARRAY* sa = ::SafeArrayCreateVector(VT_BSTR, 0,
                                           extension_directories.size());
   sa->fFeatures = sa->fFeatures | FADF_BSTR;
   ::SafeArrayLock(sa);
@@ skipping 34 matching lines @@
 STDMETHODIMP ChromeFrameActivex::Load(IPropertyBag* bag, IErrorLog* error_log) {
   DCHECK(bag);
 
   const wchar_t* event_props[] = {
     (L"onload"),
     (L"onloaderror"),
     (L"onmessage"),
     (L"onreadystatechanged"),
   };
 
-  ScopedComPtr<IHTMLObjectElement> obj_element;
+  base::win::ScopedComPtr<IHTMLObjectElement> obj_element;
   GetObjectElement(obj_element.Receive());
 
-  ScopedBstr object_id;
+  base::win::ScopedBstr object_id;
   GetObjectScriptId(obj_element, object_id.Receive());
 
   ScopedComPtr<IHTMLElement2> element;
   element.QueryFrom(obj_element);
   HRESULT hr = S_OK;
 
   for (int i = 0; SUCCEEDED(hr) && i < arraysize(event_props); ++i) {
-    ScopedBstr prop(event_props[i]);
-    ScopedVariant value;
+    base::win::ScopedBstr prop(event_props[i]);
+    base::win::ScopedVariant value;
     if (SUCCEEDED(bag->Read(prop, value.Receive(), error_log))) {
       if (value.type() != VT_BSTR ||
           FAILED(hr = CreateScriptBlockForEvent(element, object_id,
                                                 V_BSTR(&value), prop))) {
         DLOG(ERROR) << "Failed to create script block for " << prop
                     << base::StringPrintf(L"hr=0x%08X, vt=%i", hr,
                                          value.type());
       } else {
         DLOG(INFO) << "script block created for event " << prop <<
             base::StringPrintf(" (0x%08X)", hr) << " connections: " <<
             ProxyDIChromeFrameEvents<ChromeFrameActivex>::m_vec.GetSize();
       }
     } else {
       DLOG(INFO) << "event property " << prop << " not in property bag";
     }
   }
 
-  ScopedVariant src;
-  if (SUCCEEDED(bag->Read(StackBstr(L"src"), src.Receive(), error_log))) {
+  base::win::ScopedVariant src;
+  if (SUCCEEDED(bag->Read(base::win::ScopedBstr(L"src"), src.Receive(),
+                          error_log))) {
     if (src.type() == VT_BSTR) {
       hr = put_src(V_BSTR(&src));
       DCHECK(hr != E_UNEXPECTED);
     }
   }
 
-  ScopedVariant use_chrome_network;
-  if (SUCCEEDED(bag->Read(StackBstr(L"useChromeNetwork"),
+  base::win::ScopedVariant use_chrome_network;
+  if (SUCCEEDED(bag->Read(base::win::ScopedBstr(L"useChromeNetwork"),
                           use_chrome_network.Receive(), error_log))) {
     VariantChangeType(use_chrome_network.AsInput(),
                       use_chrome_network.AsInput(),
                       0, VT_BOOL);
     if (use_chrome_network.type() == VT_BOOL) {
       hr = put_useChromeNetwork(V_BOOL(&use_chrome_network));
       DCHECK(hr != E_UNEXPECTED);
     }
   }
 
@@ skipping 58 matching lines @@
       if (SUCCEEDED(service_hr) && wants_privileged)
         is_privileged_ = true;
 
       url_fetcher_->set_privileged_mode(is_privileged_);
     }
 
     std::wstring chrome_extra_arguments;
     std::wstring profile_name(GetHostProcessName(false));
     if (is_privileged_) {
       // Does the host want to provide extra arguments?
-      ScopedBstr extra_arguments_arg;
+      base::win::ScopedBstr extra_arguments_arg;
       service_hr = service->GetChromeExtraArguments(
           extra_arguments_arg.Receive());
       if (S_OK == service_hr && extra_arguments_arg)
         chrome_extra_arguments.assign(extra_arguments_arg,
                                       extra_arguments_arg.Length());
 
       ScopedBstr automated_functions_arg;
       service_hr = service->GetExtensionApisToAutomate(
           automated_functions_arg.Receive());
       if (S_OK == service_hr && automated_functions_arg) {
         std::string automated_functions(
             WideToASCII(static_cast<BSTR>(automated_functions_arg)));
         functions_enabled_.clear();
         // base::SplitString writes one empty entry for blank strings, so we
         // need this to allow specifying zero automation of API functions.
         if (!automated_functions.empty())
           base::SplitString(automated_functions, ',', &functions_enabled_);
       }
 
-      ScopedBstr profile_name_arg;
+      base::win::ScopedBstr profile_name_arg;
       service_hr = service->GetChromeProfileName(profile_name_arg.Receive());
       if (S_OK == service_hr && profile_name_arg)
         profile_name.assign(profile_name_arg, profile_name_arg.Length());
     }
 
     std::string utf8_url;
     if (url_.Length()) {
       WideToUTF8(url_, url_.Length(), &utf8_url);
     }
 
@@ skipping 189 matching lines @@
     return hr;
   }
 
   hr = bho->SetSite(web_browser2);
   if (FAILED(hr)) {
     NOTREACHED() << "ChromeFrame BHO SetSite failed. Error:"
                  << base::StringPrintf(" 0x%08X", hr);
     return hr;
   }
 
-  web_browser2->PutProperty(ScopedBstr(bho_class_id_as_string),
+  web_browser2->PutProperty(base::win::ScopedBstr(bho_class_id_as_string),
                             ScopedVariant(bho));
   return S_OK;
 }