Remove ScopedComPtr::CreateInstance()

components/storage_monitor/portable_device_watcher_win.cc

 // Copyright 2014 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.
 //
 // Any tasks that communicates with the portable device may take >100ms to
 // complete. Those tasks should be run on an blocking thread instead of the
 // UI thread.
 
 #include "components/storage_monitor/portable_device_watcher_win.h"
 
 #include <dbt.h>
+#include <objbase.h>
 #include <portabledevice.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_comptr.h"
@@ skipping 93 matching lines @@
   hr = device_manager->GetDeviceDescription(
       pnp_device_id.c_str(), base::WriteInto(description, desc_len), &desc_len);
   return (SUCCEEDED(hr) && !description->empty());
 }
 
 // On success, returns true and updates |client_info| with a reference to an
 // IPortableDeviceValues interface that holds information about the
 // application that communicates with the device.
 bool GetClientInformation(
     base::win::ScopedComPtr<IPortableDeviceValues>* client_info) {
-  HRESULT hr = client_info->CreateInstance(__uuidof(PortableDeviceValues),
-                                           NULL, CLSCTX_INPROC_SERVER);
+  HRESULT hr = ::CoCreateInstance(__uuidof(PortableDeviceValues), NULL,
+                                  CLSCTX_INPROC_SERVER,
+                                  IID_PPV_ARGS(client_info->GetAddressOf()));
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to create an instance of IPortableDeviceValues";
     return false;
   }
 
   // Attempt to set client details.
   (*client_info)->SetStringValue(WPD_CLIENT_NAME, kClientName);
   (*client_info)->SetUnsignedIntegerValue(WPD_CLIENT_MAJOR_VERSION, 0);
   (*client_info)->SetUnsignedIntegerValue(WPD_CLIENT_MINOR_VERSION, 0);
   (*client_info)->SetUnsignedIntegerValue(WPD_CLIENT_REVISION, 0);
   (*client_info)->SetUnsignedIntegerValue(
       WPD_CLIENT_SECURITY_QUALITY_OF_SERVICE, SECURITY_IMPERSONATION);
   (*client_info)->SetUnsignedIntegerValue(WPD_CLIENT_DESIRED_ACCESS,
                                           GENERIC_READ);
   return true;
 }
 
 // Opens the device for communication. |pnp_device_id| specifies the plug and
 // play device ID string. On success, returns true and updates |device| with a
 // reference to the portable device interface.
 bool SetUp(const base::string16& pnp_device_id,
            base::win::ScopedComPtr<IPortableDevice>* device) {
   base::win::ScopedComPtr<IPortableDeviceValues> client_info;
   if (!GetClientInformation(&client_info))
     return false;
 
-  HRESULT hr = device->CreateInstance(__uuidof(PortableDevice), NULL,
-                                      CLSCTX_INPROC_SERVER);
+  HRESULT hr =
+      ::CoCreateInstance(__uuidof(PortableDevice), NULL, CLSCTX_INPROC_SERVER,
+                         IID_PPV_ARGS(device->GetAddressOf()));
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to create an instance of IPortableDevice";
     return false;
   }
 
   hr = (*device)->Open(pnp_device_id.c_str(), client_info.Get());
   if (SUCCEEDED(hr))
     return true;
 
   if (hr == E_ACCESSDENIED)
     DPLOG(ERROR) << "Access denied to open the device";
   return false;
 }
 
 // Returns the unique id property key of the object specified by the
 // |object_id|.
 REFPROPERTYKEY GetUniqueIdPropertyKey(const base::string16& object_id) {
   return (object_id == WPD_DEVICE_OBJECT_ID) ?
       WPD_DEVICE_SERIAL_NUMBER : WPD_OBJECT_PERSISTENT_UNIQUE_ID;
 }
 
 // On success, returns true and populates |properties_to_read| with the
 // property key of the object specified by the |object_id|.
 bool PopulatePropertyKeyCollection(
     const base::string16& object_id,
     base::win::ScopedComPtr<IPortableDeviceKeyCollection>* properties_to_read) {
-  HRESULT hr = properties_to_read->CreateInstance(
-      __uuidof(PortableDeviceKeyCollection), NULL, CLSCTX_INPROC_SERVER);
+  HRESULT hr = ::CoCreateInstance(
+      __uuidof(PortableDeviceKeyCollection), NULL, CLSCTX_INPROC_SERVER,
+      IID_PPV_ARGS(properties_to_read->GetAddressOf()));
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to create IPortableDeviceKeyCollection instance";
     return false;
   }
   REFPROPERTYKEY key = GetUniqueIdPropertyKey(object_id);
   hr = (*properties_to_read)->Add(key);
   return SUCCEEDED(hr);
 }
 
 // Wrapper function to get content property string value.
@@ skipping 185 matching lines @@
   PortableDeviceWatcherWin::StorageObjects storage_objects;
   return GetDeviceStorageObjectsOnBlockingThread(
       pnp_device_id, &device_details->storage_objects);
 }
 
 // Wrapper function to get an instance of portable device manager. On success,
 // returns true and fills in |portable_device_mgr|. On failure, returns false.
 bool GetPortableDeviceManager(
   base::win::ScopedComPtr<IPortableDeviceManager>* portable_device_mgr) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-  HRESULT hr = portable_device_mgr->CreateInstance(
-      __uuidof(PortableDeviceManager), NULL, CLSCTX_INPROC_SERVER);
+  HRESULT hr = ::CoCreateInstance(
+      __uuidof(PortableDeviceManager), NULL, CLSCTX_INPROC_SERVER,
+      IID_PPV_ARGS(portable_device_mgr->GetAddressOf()));
   if (SUCCEEDED(hr))
     return true;
 
   // Either there is no portable device support (Windows XP with old versions of
   // Media Player) or the thread does not have COM initialized.
   DCHECK_NE(CO_E_NOTINITIALIZED, hr);
   return false;
 }
 
 // Enumerates the attached portable devices. On success, returns true and fills
@@ skipping 265 matching lines @@
     if (storage_notifications_) {
       storage_notifications_->ProcessDetach(
           storage_map_iter->second.device_id());
     }
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }
 
 }  // namespace storage_monitor