Remove implicit conversions from scoped_refptr to T* in chrome/installer

chrome/installer/util/wmi.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/installer/util/wmi.h"
 
 #include <windows.h>
 
 #include "base/basictypes.h"
 #include "base/win/scoped_bstr.h"
@@ skipping 15 matching lines @@
     return false;
 
   base::win::ScopedComPtr<IWbemServices> wmi_services_r;
   hr = wmi_locator->ConnectServer(base::win::ScopedBstr(L"ROOT\\CIMV2"),
                                   NULL, NULL, 0, NULL, 0, 0,
                                   wmi_services_r.Receive());
   if (FAILED(hr))
     return false;
 
   if (set_blanket) {
-    hr = ::CoSetProxyBlanket(wmi_services_r,
-                             RPC_C_AUTHN_WINNT,
-                             RPC_C_AUTHZ_NONE,
-                             NULL,
-                             RPC_C_AUTHN_LEVEL_CALL,
-                             RPC_C_IMP_LEVEL_IMPERSONATE,
-                             NULL,
-                             EOAC_NONE);
+    hr = ::CoSetProxyBlanket(wmi_services_r.get(), RPC_C_AUTHN_WINNT,
+                             RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL,
+                             RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);
     if (FAILED(hr))
       return false;
   }
 
   *wmi_services = wmi_services_r.Detach();
   return true;
 }
 
 bool WMI::CreateClassMethodObject(IWbemServices* wmi_services,
                                   const std::wstring& class_name,
                                   const std::wstring& method_name,
                                   IWbemClassObject** class_instance) {
   // We attempt to instantiate a COM object that represents a WMI object plus
   // a method rolled into one entity.
   base::win::ScopedBstr b_class_name(class_name.c_str());
   base::win::ScopedBstr b_method_name(method_name.c_str());
   base::win::ScopedComPtr<IWbemClassObject> class_object;
   HRESULT hr;
   hr = wmi_services->GetObject(b_class_name, 0, NULL,
                                class_object.Receive(), NULL);
   if (FAILED(hr))
     return false;
 
   base::win::ScopedComPtr<IWbemClassObject> params_def;
   hr = class_object->GetMethod(b_method_name, 0, params_def.Receive(), NULL);
   if (FAILED(hr))
     return false;
 
-  if (NULL == params_def) {
+  if (NULL == params_def.get()) {
     // You hit this special case if the WMI class is not a CIM class. MSDN
     // sometimes tells you this. Welcome to WMI hell.
     return false;
   }
 
   hr = params_def->SpawnInstance(0, class_instance);
   return(SUCCEEDED(hr));
 }
 
 bool SetParameter(IWbemClassObject* class_method,
@@ skipping 11 matching lines @@
 // the values in the returned out_params, are VT_I4, which is int32.
 
 bool WMIProcess::Launch(const std::wstring& command_line, int* process_id) {
   base::win::ScopedComPtr<IWbemServices> wmi_local;
   if (!WMI::CreateLocalConnection(true, wmi_local.Receive()))
     return false;
 
   const wchar_t class_name[] = L"Win32_Process";
   const wchar_t method_name[] = L"Create";
   base::win::ScopedComPtr<IWbemClassObject> process_create;
-  if (!WMI::CreateClassMethodObject(wmi_local, class_name, method_name,
+  if (!WMI::CreateClassMethodObject(wmi_local.get(), class_name, method_name,
                                     process_create.Receive()))
     return false;
 
   ScopedVariant b_command_line(command_line.c_str());
 
-  if (!SetParameter(process_create, L"CommandLine", b_command_line.AsInput()))
+  if (!SetParameter(process_create.get(), L"CommandLine",
+                    b_command_line.AsInput()))
     return false;
 
   base::win::ScopedComPtr<IWbemClassObject> out_params;
-  HRESULT hr = wmi_local->ExecMethod(base::win::ScopedBstr(class_name),
-                                     base::win::ScopedBstr(method_name),
-                                     0, NULL, process_create,
-                                     out_params.Receive(), NULL);
+  HRESULT hr = wmi_local->ExecMethod(
+      base::win::ScopedBstr(class_name), base::win::ScopedBstr(method_name), 0,
+      NULL, process_create.get(), out_params.Receive(), NULL);
   if (FAILED(hr))
     return false;
 
   // We're only expecting int32 or uint32 values, so no need for ScopedVariant.
   VARIANT ret_value = {VT_EMPTY};
   hr = out_params->Get(L"ReturnValue", 0, &ret_value, NULL, 0);
   if (FAILED(hr) || 0 != V_I4(&ret_value))
     return false;
 
   VARIANT pid = {VT_EMPTY};
@@ skipping 12 matching lines @@
   if (!WMI::CreateLocalConnection(true, services.Receive()))
     return base::string16();
 
   base::win::ScopedBstr query_language(L"WQL");
   base::win::ScopedBstr query(L"SELECT * FROM Win32_ComputerSystem");
   base::win::ScopedComPtr<IEnumWbemClassObject> enumerator;
   HRESULT hr = services->ExecQuery(
       query_language, query,
       WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL,
       enumerator.Receive());
-  if (FAILED(hr) || !enumerator)
+  if (FAILED(hr) || !enumerator.get())
     return base::string16();
 
   base::win::ScopedComPtr<IWbemClassObject> class_object;
   ULONG items_returned = 0;
   hr = enumerator->Next(WBEM_INFINITE, 1,  class_object.Receive(),
                         &items_returned);
   if (!items_returned)
     return base::string16();
 
   base::win::ScopedVariant manufacturer;
   class_object->Get(L"Manufacturer", 0, manufacturer.Receive(), 0, 0);
   base::win::ScopedVariant model;
   class_object->Get(L"Model", 0, model.Receive(), 0, 0);
 
   base::string16 model_string;
   if (manufacturer.type() == VT_BSTR) {
     model_string = V_BSTR(&manufacturer);
     if (model.type() == VT_BSTR)
       model_string += L" ";
   }
   if (model.type() == VT_BSTR)
     model_string += V_BSTR(&model);
 
   return model_string;
 }
 
 }  // namespace installer