Media Galleries API Metadata: SafeMediaMetadataParser and IPCTunnelDataReader.

chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.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.
+
+#include "chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "chrome/browser/extensions/blob_reader.h"
+#include "chrome/common/chrome_utility_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_data.h"
+#include "content/public/browser/utility_process_host.h"
+
+using content::BrowserThread;
+
+namespace metadata {
+
+namespace {
+
+// Completes the Blob byte request by forwarding it to the utility process.
+void OnBlobReaderDone(
+    const base::WeakPtr<content::UtilityProcessHost>& utility_process_host,
+    int64 request_id,
+    scoped_ptr<std::string> data) {

[vandebo (ex-Chrome), 2014/01/08 17:48:06]

Sorry, I didn't know that BlobReader returns std::string.  I think that's wrong,
but in that case, there's no reason to copy it again and you should use
std::string throughout.

[tommycli, 2014/01/08 18:59:37]

Done.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!utility_process_host.get())
+    return;
+  std::vector<unsigned char> byte_vector(data->size());
+  std::copy(data->begin(), data->end(), byte_vector.begin());
+  utility_process_host->Send(new ChromeUtilityMsg_RequestBlobBytes_Finished(
+      request_id, byte_vector));
+}
+
+}  // namespace
+
+SafeMediaMetadataParser::SafeMediaMetadataParser(Profile* profile,
+                                                 const std::string& blob_uuid,
+                                                 int64 blob_size,
+                                                 const std::string& mime_type)
+    : profile_(profile),
+      blob_uuid_(blob_uuid),
+      blob_size_(blob_size),
+      mime_type_(mime_type),
+      parser_state_(INITIAL_STATE) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+void SafeMediaMetadataParser::Start(const DoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());

[vandebo (ex-Chrome), 2014/01/08 17:48:06]

nit: move to StartWokOnIOThread

[tommycli, 2014/01/08 18:59:37]

Done.

+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&SafeMediaMetadataParser::StartWorkOnIOThread, this,
+                 callback));
+}
+
+SafeMediaMetadataParser::~SafeMediaMetadataParser() {
+}
+
+void SafeMediaMetadataParser::StartWorkOnIOThread(
+    const DoneCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_EQ(INITIAL_STATE, parser_state_);
+
+  callback_ = callback;
+
+  utility_process_host_ = content::UtilityProcessHost::Create(
+      this, base::MessageLoopProxy::current())->AsWeakPtr();
+
+  utility_process_host_->Send(
+      new ChromeUtilityMsg_ParseMediaMetadata(mime_type_, blob_size_));
+
+  parser_state_ = STARTED_PARSING_STATE;
+}
+
+void SafeMediaMetadataParser::OnParseMediaMetadataFinished(
+    bool parse_success,
+    const base::DictionaryValue& metadata_dictionary) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback_.is_null());
+
+  if (parser_state_ != STARTED_PARSING_STATE)
+    return;
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(callback_, parse_success, base::Passed(
+          make_scoped_ptr(metadata_dictionary.DeepCopy()))));
+  parser_state_ = FINISHED_PARSING_STATE;
+}
+
+void SafeMediaMetadataParser::OnUtilityProcessRequestBlobBytes(
+    int64 request_id,

[vandebo (ex-Chrome), 2014/01/08 17:48:06]

nit: args fit on one line.

[tommycli, 2014/01/08 18:59:37]

Kind of pathological, but officially, this is preferred:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...

+    int64 byte_start,
+    int64 length) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // BlobReader is self-deleting.
+  BlobReader* reader = new BlobReader(
+      profile_,
+      blob_uuid_,
+      base::Bind(&OnBlobReaderDone, utility_process_host_, request_id));
+  reader->SetByteRange(byte_start, length);
+  reader->Start();
+}
+
+void SafeMediaMetadataParser::OnProcessCrashed(int exit_code) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback_.is_null());
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(callback_, false,
+                 base::Passed(scoped_ptr<base::DictionaryValue>())));
+  parser_state_ = FINISHED_PARSING_STATE;
+}
+
+bool SafeMediaMetadataParser::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(SafeMediaMetadataParser, message)
+    IPC_MESSAGE_HANDLER(
+        ChromeUtilityHostMsg_ParseMediaMetadata_Finished,
+        OnParseMediaMetadataFinished)
+    IPC_MESSAGE_HANDLER(
+        ChromeUtilityHostMsg_RequestBlobBytes,
+        OnUtilityProcessRequestBlobBytes)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+}  // namespace metadata