Rename ScopedComPtr::get() to ScopedComPtr::Get()

chrome/browser/media_galleries/win/mtp_device_operations_util.cc

 // Copyright (c) 2013 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/browser/media_galleries/win/mtp_device_operations_util.h"
 
 #include <portabledevice.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 57 matching lines @@
 // the device objects. On failure, returns NULL.
 // |parent_id| specifies the parent object identifier.
 base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs> GetDeviceObjectEnumerator(
     IPortableDevice* device,
     const base::string16& parent_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!parent_id.empty());
   base::win::ScopedComPtr<IPortableDeviceContent> content =
       GetDeviceContent(device);
-  if (!content.get())
+  if (!content.Get())
     return base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs>();
 
   base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs> enum_object_ids;
   if (SUCCEEDED(content->EnumObjects(0, parent_id.c_str(), NULL,
                                      enum_object_ids.Receive())))
     return enum_object_ids;
   return base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs>();
 }
 
 // Returns whether the object is a directory/folder/album. |properties_values|
@@ skipping 86 matching lines @@
                       base::Time* last_modified_time) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!object_id.empty());
   DCHECK(name);
   DCHECK(is_directory);
   DCHECK(size);
   DCHECK(last_modified_time);
   base::win::ScopedComPtr<IPortableDeviceContent> content =
       GetDeviceContent(device);
-  if (!content.get())
+  if (!content.Get())
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceProperties> properties;
   HRESULT hr = content->Properties(properties.Receive());
   if (FAILED(hr))
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceKeyCollection> properties_to_read;
   hr = properties_to_read.CreateInstance(__uuidof(PortableDeviceKeyCollection),
                                          NULL,
                                          CLSCTX_INPROC_SERVER);
   if (FAILED(hr))
     return false;
 
   if (FAILED(properties_to_read->Add(WPD_OBJECT_CONTENT_TYPE)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_FORMAT)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_ORIGINAL_FILE_NAME)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_NAME)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_DATE_MODIFIED)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_DATE_CREATED)) ||
       FAILED(properties_to_read->Add(WPD_OBJECT_SIZE)))
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceValues> properties_values;
   hr = properties->GetValues(object_id.c_str(),
-                             properties_to_read.get(),
+                             properties_to_read.Get(),
                              properties_values.Receive());
   if (FAILED(hr))
     return false;
 
-  *is_directory = IsDirectory(properties_values.get());
-  *name = GetObjectName(properties_values.get());
+  *is_directory = IsDirectory(properties_values.Get());
+  *name = GetObjectName(properties_values.Get());
   if (name->empty())
     return false;
 
   if (*is_directory) {
     // Directory entry does not have size and last modified date property key
     // values.
     *size = 0;
     *last_modified_time = base::Time();
     return true;
   }
 
   // Try to get the last modified time, but don't fail if we can't.
-  GetLastModifiedTime(properties_values.get(), last_modified_time);
+  GetLastModifiedTime(properties_values.Get(), last_modified_time);
 
-  int64_t object_size = GetObjectSize(properties_values.get());
+  int64_t object_size = GetObjectSize(properties_values.Get());
   if (object_size < 0)
     return false;
   *size = object_size;
   return true;
 }
 
 // Creates an MTP device object entry for the given |device| and |object_id|.
 // On success, returns true and fills in |entry|.
 MTPDeviceObjectEntry GetMTPDeviceObjectEntry(IPortableDevice* device,
                                              const base::string16& object_id) {
@@ skipping 20 matching lines @@
 bool GetMTPDeviceObjectEntries(IPortableDevice* device,
                                const base::string16& directory_object_id,
                                const base::string16& object_name,
                                MTPDeviceObjectEntries* object_entries) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!directory_object_id.empty());
   DCHECK(object_entries);
   base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs> enum_object_ids =
       GetDeviceObjectEnumerator(device, directory_object_id);
-  if (!enum_object_ids.get())
+  if (!enum_object_ids.Get())
     return false;
 
   // Loop calling Next() while S_OK is being returned.
   const DWORD num_objects_to_request = 10;
   const bool get_all_entries = object_name.empty();
   for (HRESULT hr = S_OK; hr == S_OK;) {
     DWORD num_objects_fetched = 0;
     std::unique_ptr<base::char16* []> object_ids(
         new base::char16*[num_objects_to_request]);
     hr = enum_object_ids->Next(num_objects_to_request,
@@ skipping 25 matching lines @@
   DCHECK(!pnp_device_id.empty());
   base::win::ScopedComPtr<IPortableDeviceValues> client_info;
   if (!GetClientInformation(&client_info))
     return base::win::ScopedComPtr<IPortableDevice>();
   base::win::ScopedComPtr<IPortableDevice> device;
   HRESULT hr = device.CreateInstance(__uuidof(PortableDevice), NULL,
                                      CLSCTX_INPROC_SERVER);
   if (FAILED(hr))
     return base::win::ScopedComPtr<IPortableDevice>();
 
-  hr = device->Open(pnp_device_id.c_str(), client_info.get());
+  hr = device->Open(pnp_device_id.c_str(), client_info.Get());
   if (SUCCEEDED(hr))
     return device;
   if (hr == E_ACCESSDENIED)
     DPLOG(ERROR) << "Access denied to open the device";
   return base::win::ScopedComPtr<IPortableDevice>();
 }
 
 base::File::Error GetFileEntryInfo(
     IPortableDevice* device,
     const base::string16& object_id,
@@ skipping 23 matching lines @@
 
 HRESULT GetFileStreamForObject(IPortableDevice* device,
                                const base::string16& file_object_id,
                                IStream** file_stream,
                                DWORD* optimal_transfer_size) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!file_object_id.empty());
   base::win::ScopedComPtr<IPortableDeviceContent> content =
       GetDeviceContent(device);
-  if (!content.get())
+  if (!content.Get())
     return E_FAIL;
 
   base::win::ScopedComPtr<IPortableDeviceResources> resources;
   HRESULT hr = content->Transfer(resources.Receive());
   if (FAILED(hr))
     return hr;
   return resources->GetStream(file_object_id.c_str(), WPD_RESOURCE_DEFAULT,
                               STGM_READ, optimal_transfer_size,
                               file_stream);
 }
@@ skipping 35 matching lines @@
       object_entries.empty())
     return base::string16();
   // TODO(thestig): This DCHECK can fail. Multiple MTP objects can have
   // the same name. Handle the situation gracefully. Refer to crbug.com/169930
   // for more details.
   DCHECK_EQ(1U, object_entries.size());
   return object_entries[0].object_id;
 }
 
 }  // namespace media_transfer_protocol