Media Galleries: Fix PTP Devices on Windows

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 <algorithm>
 
@@ skipping 100 matching lines @@
   HRESULT hr = properties_values->GetStringValue(WPD_OBJECT_ORIGINAL_FILE_NAME,
                                                  &buffer);
   if (FAILED(hr))
     hr = properties_values->GetStringValue(WPD_OBJECT_NAME, &buffer);
   if (SUCCEEDED(hr))
     result.assign(buffer);
   return result;
 }
 
 // Gets the last modified time of the object from the property key values
-// specified by the |properties_values|. On success, returns true and fills in
+// specified by the |properties_values|. On success, fills in
 // |last_modified_time|.
-bool GetLastModifiedTime(IPortableDeviceValues* properties_values,
+void GetLastModifiedTime(IPortableDeviceValues* properties_values,
                          base::Time* last_modified_time) {
   DCHECK(properties_values);
   DCHECK(last_modified_time);
   base::win::ScopedPropVariant last_modified_date;
   HRESULT hr = properties_values->GetValue(WPD_OBJECT_DATE_MODIFIED,
                                            last_modified_date.Receive());
   if (FAILED(hr))
-    return false;
+    return;
 
-  bool last_modified_time_set = (last_modified_date.get().vt == VT_DATE);
-  if (last_modified_time_set) {
-    SYSTEMTIME system_time;
-    FILETIME file_time;
-    if (VariantTimeToSystemTime(last_modified_date.get().date, &system_time) &&
-        SystemTimeToFileTime(&system_time, &file_time)) {
-      *last_modified_time = base::Time::FromFileTime(file_time);
-    } else {
-      last_modified_time_set = false;
-    }
+  // Some PTP devices don't provide an mtime. Try using the ctime instead.
+  if (last_modified_date.get().vt != VT_DATE) {
+    last_modified_date.Reset();
+    HRESULT hr = properties_values->GetValue(WPD_OBJECT_DATE_CREATED,
+                                             last_modified_date.Receive());
+    if (FAILED(hr))
+      return;
   }
-  return last_modified_time_set;
+
+  SYSTEMTIME system_time;
+  FILETIME file_time;
+  if (last_modified_date.get().vt == VT_DATE &&
+      VariantTimeToSystemTime(last_modified_date.get().date, &system_time) &&
+      SystemTimeToFileTime(&system_time, &file_time)) {
+    *last_modified_time = base::Time::FromFileTime(file_time);
+  }
 }
 
 // Gets the size of the file object in bytes from the property key values
 // specified by the |properties_values|. On success, returns true and fills
 // in |size|.
 bool GetObjectSize(IPortableDeviceValues* properties_values, int64* size) {
   DCHECK(properties_values);
   DCHECK(size);
   ULONGLONG actual_size;
   HRESULT hr = properties_values->GetUnsignedLargeIntegerValue(WPD_OBJECT_SIZE,
                                                                &actual_size);
   bool success = SUCCEEDED(hr) && (actual_size <= kint64max);
   if (success)
     *size = static_cast<int64>(actual_size);
   return success;
 }
 
 // Gets the details of the object specified by the |object_id| given the media
 // transfer protocol |device|. On success, returns true and fills in |name|,
-// |is_directory|, |size| and |last_modified_time|.
+// |is_directory|, |size|. |last_modified_time| will be filled in if possible,
+// but failure to get it doesn't prevent success.
 bool GetObjectDetails(IPortableDevice* device,
                       const base::string16 object_id,
                       base::string16* name,
                       bool* is_directory,
                       int64* size,
                       base::Time* last_modified_time) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!object_id.empty());
   DCHECK(name);
@@ skipping 15 matching lines @@
                                          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_values.Receive());
   if (FAILED(hr))
     return false;
 
   *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;
   }
-  return (GetObjectSize(properties_values.get(), size) &&
-          GetLastModifiedTime(properties_values.get(), last_modified_time));
+
+  // Try to get the last modified time, but don't fail if we can't.
+  GetLastModifiedTime(properties_values.get(), last_modified_time);
+
+  return GetObjectSize(properties_values.get(), size);
 }
 
 // Creates an MTP device object entry for the given |device| and |object_id|.
 // On success, returns true and fills in |entry|.
 bool GetMTPDeviceObjectEntry(IPortableDevice* device,
                              const base::string16& object_id,
                              MTPDeviceObjectEntry* entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!object_id.empty());
@@ skipping 165 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