[Media Gallery] Added code to support mtp device media file system on Windows.

chrome/browser/media_gallery/win/mtp_device_operations_util.cc

+// Copyright (c) 2012 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.
+//
+// MTPDeviceOperationsUtil implementation.
+
+#include "chrome/browser/media_gallery/win/mtp_device_operations_util.h"
+
+#include <portabledevice.h>
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/time.h"
+#include "base/win/scoped_co_mem.h"
+#include "chrome/browser/system_monitor/removable_device_constants.h"
+#include "chrome/common/chrome_constants.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace chrome {
+
+namespace {
+
+// 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) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(client_info);
+  HRESULT hr = client_info->CreateInstance(__uuidof(PortableDeviceValues),
+                                           NULL, CLSCTX_INPROC_SERVER);
+  if (FAILED(hr)) {
+    DPLOG(ERROR) << "Failed to create an instance of IPortableDeviceValues";
+    return false;
+  }
+
+  (*client_info)->SetStringValue(WPD_CLIENT_NAME,
+                                 chrome::kBrowserProcessExecutableName);
+  (*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;
+}
+
+// Gets the content interface of the portable |device|. On success, returns
+// true and fills in |content| with the given portable |device| content.
+bool GetDeviceContent(IPortableDevice* device,
+                      IPortableDeviceContent** content) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(content);
+  return SUCCEEDED(device->Content(content));
+}
+
+// Gets the portable |device| enumerator interface to enumerate the objects.
+// |parent_id| specifies the parent object identifier. On success, returns
+// true and fills in |enum_object_ids|.
+bool GetDeviceObjectEnumerator(IPortableDevice* device,
+                               const string16& parent_id,
+                               IEnumPortableDeviceObjectIDs** enum_object_ids) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!parent_id.empty());
+  DCHECK(enum_object_ids);
+  base::win::ScopedComPtr<IPortableDeviceContent> content;
+  if (!GetDeviceContent(device, content.Receive()))
+    return false;
+
+  HRESULT hr = content->EnumObjects(0, parent_id.c_str(), NULL,
+                                    enum_object_ids);
+  return SUCCEEDED(hr);
+}
+
+// Writes data from |stream| to the snapshot file specified by |local_path|. On
+// success, returns true and the stream contents are appended to snapshot file.
+bool WriteStreamContentsToFile(IStream* stream,
+                               size_t optimal_transfer_size,
+                               const FilePath& local_path) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(stream);
+  DCHECK_GT(optimal_transfer_size, 0u);
+  DCHECK(!local_path.empty());
+  DWORD read = 0;
+  HRESULT hr = S_OK;
+  do {
+    std::string buffer;
+    hr = stream->Read(WriteInto(&buffer, optimal_transfer_size + 1),
+                      optimal_transfer_size, &read);
+    if ((hr != S_OK) && (hr != S_FALSE))

[Peter Kasting, 2012/12/21 18:13:30]

Nit: I suggest explaining S_FALSE (the comment you wrote me about it would be a
pretty good explanation).

[kmadhusu, 2013/01/02 19:48:31]

Done.

+      return false;
+    if (read) {
+      buffer.erase(read);
+      DCHECK_EQ(read, buffer.length());
+      int data_len = static_cast<int>(buffer.length());
+      if (file_util::AppendToFile(local_path, buffer.c_str(), data_len) !=
+          data_len)
+        return false;
+    }
+  } while ((read > 0) && SUCCEEDED(hr));
+  return true;
+}
+
+// Returns whether the object is a directory/folder/album. |properties_values|
+// contains the object property key values.
+bool IsDirectory(IPortableDeviceValues* properties_values) {
+  DCHECK(properties_values);
+  GUID content_type;
+  HRESULT hr = properties_values->GetGuidValue(WPD_OBJECT_CONTENT_TYPE,
+                                               &content_type);
+  if (FAILED(hr))
+    return false;
+  return ((content_type == WPD_CONTENT_TYPE_AUDIO_ALBUM) ||
+      (content_type == WPD_CONTENT_TYPE_FOLDER) ||
+      (content_type == WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT) ||
+      (content_type == WPD_CONTENT_TYPE_IMAGE_ALBUM) ||
+      (content_type == WPD_CONTENT_TYPE_MIXED_CONTENT_ALBUM) ||
+      (content_type == WPD_CONTENT_TYPE_VIDEO_ALBUM));
+}
+
+// Returns the friendly name of the object from the property key values
+// specified by the |properties_values|.
+string16 GetObjectName(IPortableDeviceValues* properties_values,
+                       bool is_directory) {
+  DCHECK(properties_values);
+  base::win::ScopedCoMem<char16> buffer;
+  REFPROPERTYKEY key =
+      is_directory ? WPD_OBJECT_NAME : WPD_OBJECT_ORIGINAL_FILE_NAME;
+  HRESULT hr = properties_values->GetStringValue(key, &buffer);
+  return SUCCEEDED(hr) ? static_cast<const char16*>(buffer) : string16();
+}
+
+// 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
+// |last_modified_time|.
+bool GetLastModifiedTime(IPortableDeviceValues* properties_values,
+                         base::Time* last_modified_time) {
+  DCHECK(properties_values);
+  DCHECK(last_modified_time);
+  PROPVARIANT last_modified_date = {0};
+  PropVariantInit(&last_modified_date);
+  HRESULT hr = properties_values->GetValue(WPD_OBJECT_DATE_MODIFIED,
+                                           &last_modified_date);
+  if (FAILED(hr))
+    return false;
+
+  bool last_modified_time_set = (last_modified_date.vt == VT_DATE);
+  if (last_modified_date.vt == VT_DATE) {

[Peter Kasting, 2012/12/21 18:13:30]

Nit: Use |last_modified_time_set| here for brevity/efficiency

[kmadhusu, 2013/01/02 19:48:31]

Done.

+    SYSTEMTIME system_time;
+    FILETIME file_time;
+    if (VariantTimeToSystemTime(last_modified_date.date, &system_time) &&
+        SystemTimeToFileTime(&system_time, &file_time))
+      *last_modified_time = base::Time::FromFileTime(file_time);
+    else
+      last_modified_time_set = false;
+  }
+  if (!last_modified_time_set)
+    *last_modified_time = base::Time();

[Peter Kasting, 2012/12/21 18:13:30]

Doesn't explicitly clearing this violate the function contract?  The comments
say we set this variable if everything succeeded.  On failure shouldn't we just
leave it alone?

[kmadhusu, 2013/01/02 19:48:31]

As per your earlier
comment(https://codereview.chromium.org/11297002/diff/35004/chrome/browser/media_gallery/win/mtp_device_operations_util.cc#newcode198),
you asked me to reset the outparam explicitly. 

[Peter Kasting, 2013/01/02 21:41:09]

No, I asked you to make sure it was set when the function returns true.  Here
you're setting it when you will return false.  That's not right.

[kmadhusu, 2013/01/02 23:49:48]

Fixed.

+  PropVariantClear(&last_modified_date);
+  return last_modified_time_set;

[Peter Kasting, 2012/12/21 18:13:30]

You don't have to do this in this CL, but you could make this simpler and safer
by using a scoping object for your PROPVARIANT.  Note that
core_audio_util_win.cc locally defines a ScopedPropVariant, and the new
scoped_ptr<> capabilities also give you the ability to simply use a scoped_ptr<>
with a custom deleter.  It would be nice to have a followup cleanup patch that
removes all the PropVariantClear() calls in the codebase (looks like 9
currently) and replaces them with this.

[kmadhusu, 2013/01/02 19:48:31]

I will submit a cleanup patch later. 

+}
+
+// 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);
+  HRESULT hr = properties_values->GetUnsignedLargeIntegerValue(
+      WPD_OBJECT_SIZE, reinterpret_cast<ULONGLONG*>(size));
+  return SUCCEEDED(hr);
+}
+
+// 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|.
+bool GetObjectDetails(IPortableDevice* device,
+                      const string16 object_id,
+                      string16* name,
+                      bool* is_directory,
+                      int64* size,
+                      base::Time* last_modified_time) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!object_id.empty());
+  DCHECK(name);
+  DCHECK(is_directory);
+  DCHECK(size);
+  DCHECK(last_modified_time);
+  base::win::ScopedComPtr<IPortableDeviceContent> content;
+  if (!GetDeviceContent(device, content.Receive()))
+    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_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(), *is_directory);
+  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));
+}
+
+// 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 string16& object_id,
+                             MTPDeviceObjectEntry* entry) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!object_id.empty());
+  DCHECK(entry);
+  string16 name;
+  bool is_directory;
+  int64 size;
+  base::Time last_modified_time;
+  if (!GetObjectDetails(device, object_id, &name, &is_directory, &size,
+                        &last_modified_time))
+    return false;
+  *entry = MTPDeviceObjectEntry(object_id, name, is_directory, size,
+                                last_modified_time);
+  return true;
+}
+
+// Gets the entries of the directory specified by |directory_object_id| from
+// the given MTP |device|. Set |get_all_entries| to true to get all the entries
+// of the directory. To request a specific object entry, set |get_all_entries|
+// to false and set |object_name| to the name of the required object. On
+// success returns true and set |object_entries|.
+bool GetMTPDeviceObjectEntries(IPortableDevice* device,
+                               const string16& directory_object_id,
+                               bool get_all_entries,
+                               const string16& object_name,
+                               MTPDeviceObjectEntries* object_entries) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!directory_object_id.empty());
+  DCHECK(object_entries);
+  base::win::ScopedComPtr<IEnumPortableDeviceObjectIDs> enum_object_ids;
+  if (!GetDeviceObjectEnumerator(device, directory_object_id,
+                                 enum_object_ids.Receive()))
+    return false;
+
+  // Loop calling Next() while S_OK is being returned.
+  DWORD num_objects_to_request = 10;
+  for (HRESULT hr = S_OK; hr == S_OK;) {
+    DWORD num_objects_fetched = 0;
+    typedef base::win::ScopedCoMem<char16> ScopedObjectID;
+    scoped_ptr<ScopedObjectID[]> object_ids(
+        new ScopedObjectID[num_objects_to_request]);
+    ZeroMemory(object_ids.get(), num_objects_to_request);

[Peter Kasting, 2012/12/21 18:13:30]

Don't do this.  new[] will default-initialize non-POD types for you.

(You can also force default-initialization of POD types by appending a () to the
[], but it's not necessary in your case.)

[kmadhusu, 2013/01/02 19:48:31]

Removed ZeroMemory(...).

+    hr = enum_object_ids->Next(num_objects_to_request,
+                               static_cast<char16**>(&object_ids[0]),

[Peter Kasting, 2012/12/21 18:13:30]

This makes me leery.  It actually works based on how ScopedCoMem is defined
today, but if someone were to change that class definition, this could break.

I think ScopedCoMem is a good choice for individual strings, but in a case like
this with an array, I'd actually just go ahead and call CoTaskMemFree()
directly.

[kmadhusu, 2013/01/02 19:48:31]

Fixed. Used scoped_ptr<char16*[]> and CoTaskMemFree() directly.

+                               &num_objects_fetched);
+    for (DWORD index = 0; index < num_objects_fetched; ++index) {
+      MTPDeviceObjectEntry entry;
+      if (GetMTPDeviceObjectEntry(device,
+                                  static_cast<char16*>(object_ids[index]),
+                                  &entry)) {
+        if (get_all_entries) {
+          object_entries->push_back(entry);
+        } else if (entry.name == object_name) {
+          object_entries->push_back(entry);  // Object entry found.
+          break;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace
+
+
+// MTPDeviceOperationsUtil ----------------------------------------------------
+
+// static
+bool MTPDeviceOperationsUtil::OpenDevice(
+    const string16& pnp_device_id,
+    base::win::ScopedComPtr<IPortableDevice>* device) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(!pnp_device_id.empty());
+  DCHECK(device);
+  base::win::ScopedComPtr<IPortableDeviceValues> client_info;
+  if (!GetClientInformation(&client_info))
+    return false;
+  HRESULT hr = device->CreateInstance(__uuidof(PortableDevice), NULL,
+                                      CLSCTX_INPROC_SERVER);
+  if (FAILED(hr))
+    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;
+}
+
+// static
+base::PlatformFileError MTPDeviceOperationsUtil::GetFileEntryInfo(
+    IPortableDevice* device,
+    const string16& object_id,
+    base::PlatformFileInfo* file_entry_info) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!object_id.empty());
+  DCHECK(file_entry_info);
+  MTPDeviceObjectEntry entry;
+  if (!GetMTPDeviceObjectEntry(device, object_id, &entry))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+
+  file_entry_info->size = entry.size;
+  file_entry_info->is_directory = entry.is_directory;
+  file_entry_info->is_symbolic_link = false;
+  file_entry_info->last_modified = entry.last_modified_time;
+  file_entry_info->last_accessed = entry.last_modified_time;
+  file_entry_info->creation_time = base::Time();
+  return base::PLATFORM_FILE_OK;
+}
+
+// static
+bool MTPDeviceOperationsUtil::GetDirectoryEntries(
+    IPortableDevice* device,
+    const string16& directory_object_id,
+    MTPDeviceObjectEntries* object_entries) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  return GetMTPDeviceObjectEntries(device, directory_object_id, true,
+                                   string16(), object_entries);
+}
+
+// static
+bool MTPDeviceOperationsUtil::WriteFileObjectData(
+    IPortableDevice* device,
+    const string16& file_object_id,
+    const FilePath& local_path) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(device);
+  DCHECK(!file_object_id.empty());
+  DCHECK(!local_path.value().empty());
+  base::win::ScopedComPtr<IPortableDeviceContent> content;
+  if (!GetDeviceContent(device, content.Receive()))
+    return false;
+
+  base::win::ScopedComPtr<IPortableDeviceResources> resources;
+  HRESULT hr = content->Transfer(resources.Receive());
+  if (FAILED(hr))
+    return false;
+
+  base::win::ScopedComPtr<IStream> file_stream;
+  DWORD optimal_transfer_size = 0;
+  hr = resources->GetStream(file_object_id.c_str(), WPD_RESOURCE_DEFAULT,
+                            STGM_READ, &optimal_transfer_size,
+                            file_stream.Receive());
+  if (FAILED(hr))
+    return false;
+  return WriteStreamContentsToFile(file_stream.get(), optimal_transfer_size,
+                                   local_path);
+}
+
+// static
+string16 MTPDeviceOperationsUtil::GetObjectIdFromName(
+    IPortableDevice* device,
+    const string16& parent_id,
+    const string16& object_name) {
+  MTPDeviceObjectEntries object_entries;
+  if (!GetMTPDeviceObjectEntries(device, parent_id, false, object_name,
+                                 &object_entries) ||
+      object_entries.empty())
+    return string16();
+  DCHECK_EQ(1U, object_entries.size());
+  return object_entries[0].object_id;
+}
+
+}  // namespace chrome