[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());

[Ryan Sleevi, 2013/01/05 03:00:58]

DESIGN: Is it really a design constraint that you run these on the blocking
pool?

It seems throughout this CL, that you're using the "Blocking Pool" as a
substitute for base::ThreadRestrictions::AssertIOAllowed(), with
AssertIOAllowed() being much more preferable than binding to any particular
pool.

[kmadhusu, 2013/01/08 03:19:40]

Replaced some of the instances of
"DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());"
with "base::ThreadRestrictions::AssertIOAllowed()".

I still have some DCHECKs on other files to make sure the function is called on
the right thread.

+  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;

[Ryan Sleevi, 2013/01/05 03:00:58]

perf: Constantly re-allocating a new buffer inside the loop. You should declare
|buffer| outside.

[kmadhusu, 2013/01/08 03:19:40]

Done.

+    hr = stream->Read(WriteInto(&buffer, optimal_transfer_size + 1),
+                      optimal_transfer_size, &read);
+    // IStream::Read() returns S_FALSE when the actual number of bytes read from
+    // the stream object is less than the number of bytes requested (aka
+    // |optimal_transfer_size|). This indicates the end of the stream has been
+    // reached. Therefore, it is fine to return true when Read() returns
+    // S_FALSE.
+    if ((hr != S_OK) && (hr != S_FALSE))
+      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;

[Ryan Sleevi, 2013/01/05 03:00:58]

style: should be using braces here

[Peter Kasting, 2013/01/05 03:17:19]

Braces are optional if the body is one line.  It does not matter whether or not
the conditional is multiline.

Personally I encourage no braces in these scenarios, but more than anything, I
encourage consistency within a file and with the surrounding code.

(This reply applies anywhere you've made this comment)

+    }
+  } 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_time_set) {
+    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

[Ryan Sleevi, 2013/01/05 03:00:58]

style: should be using braces here

[kmadhusu, 2013/01/08 03:19:40]

Ignoring this comment since the braces are optional.

+      last_modified_time_set = false;
+  }
+  PropVariantClear(&last_modified_date);
+  return last_modified_time_set;
+}
+
+// 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;

[Ryan Sleevi, 2013/01/05 03:00:58]

style: should be using braces here

+
+  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;

[Ryan Sleevi, 2013/01/05 03:00:58]

style: Should be using braces here

+  *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;
+    scoped_ptr<char16*[]> object_ids(new char16*[num_objects_to_request]);
+    hr = enum_object_ids->Next(num_objects_to_request,
+                               object_ids.get(),
+                               &num_objects_fetched);
+    for (DWORD index = 0; index < num_objects_fetched; ++index) {
+      MTPDeviceObjectEntry entry;
+      if (GetMTPDeviceObjectEntry(device,
+                                  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;
+        }
+      }
+    }
+    for (DWORD index = 0; index < num_objects_fetched; ++index)
+      CoTaskMemFree(object_ids[index]);
+  }
+  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())

[Ryan Sleevi, 2013/01/05 03:00:58]

style: You should be using braces here

+    return string16();
+  DCHECK_EQ(1U, object_entries.size());

[Ryan Sleevi, 2013/01/05 03:00:58]

Should be a CHECK_EQ - you have no guarantee the next line will crash (it's
undefined behaviour)

[Peter Kasting, 2013/01/05 03:17:19]

That's fine.  We don't need to force a crash when a precondition is unsatisfied.
 It's completely OK to have undefined behavior happen (and in fact we do it in
many places throughout Chrome).

CHECK should only be used when violating the assertion would lead directly to an
exploitable security hole, or when we're trying to track down why some crash is
happening.  Otherwise, DCHECK is preferable.

[Ryan Sleevi, 2013/01/05 03:44:37]

You absolutely should force a crash when you're about to do something with
potentially uninitialized memory. Either that, or handle it - preferably handle
it if it's handleable.

Use CHECK here, or return string16() and drop the DCHECK.

The use of an uninitialized memory like this is usually a key step in an attack,
by carefully aligning things so that the uninitialized memory can be used to
determine the address of a vtable or undermine ASLR, and from there build a ROP
bundle. This is a common issue in WebKit code with heap spraying and U-A-Fs.

[kmadhusu, 2013/01/07 19:17:26]

rsleevi@: At line 410, I already handled the object_entries.empty() case and
returned string16(). |object_entries| is completely valid at line 412. I am just
making sure that the total number of entries is 1. If the number of entries is
more than one, we are just going to return the zeroth entry value. Based on my
testing, this DCHECK is always true. So, we don't need a CHECK_EQ here.

[Ryan Sleevi, 2013/01/07 19:29:29]

ACK - you're right. DCHECK is totally fine here then.

+  return object_entries[0].object_id;
+}
+
+}  // namespace chrome