Files.app: Implement md5 hashing over file streams.

chrome/browser/drive/drive_api_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.
 
 #include "chrome/browser/drive/drive_api_util.h"
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "net/base/escape.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "storage/browser/blob/file_stream_reader.h"
 #include "third_party/re2/re2/re2.h"
 #include "url/gurl.h"
 
 namespace drive {
 namespace util {
 namespace {
 
 struct HostedDocumentKind {
   const char* mime_type;
   const char* extension;
@@ skipping 127 matching lines @@
 
     offset += result;
     base::MD5Update(&context, base::StringPiece(buffer.get(), result));
   }
 
   base::MD5Digest digest;
   base::MD5Final(&digest, &context);
   return MD5DigestToBase16(digest);
 }
 
+FileStreamMd5Digester::FileStreamMd5Digester()
+    : buffer_(new net::IOBuffer(kBufferSize_)) {
+}
+
+FileStreamMd5Digester::~FileStreamMd5Digester() {
+}
+
+void FileStreamMd5Digester::GetMd5Digest(
+    scoped_ptr<storage::FileStreamReader> stream_reader,
+    const ResultCallback& callback) {
+  reader_ = stream_reader.Pass();
+  callback_ = callback;
+  base::MD5Init(&md5_context_);
+
+  // Start the read/hash.
+  ReadNextChunk();
+}
+
+void FileStreamMd5Digester::ReadNextChunk() {
+  const int result =
+      reader_->Read(buffer_.get(), kBufferSize_,
+                    base::Bind(&FileStreamMd5Digester::OnChunkRead, this));
+  if (result != net::ERR_IO_PENDING) {
+    OnChunkRead(result);
+  }
+}
+
+void FileStreamMd5Digester::OnChunkRead(int result) {
+  if (result < 0) {
+    // Error - just return empty string.
+    callback_.Run("");
+    return;
+  } else if (result == 0) {
+    // EOF.
+    base::MD5Digest digest;
+    base::MD5Final(&digest, &md5_context_);
+    std::string result = MD5DigestToBase16(digest);
+    callback_.Run(result);
+    return;
+  }
+
+  // Read data and digest it.
+  base::MD5Update(&md5_context_, base::StringPiece(buffer_->data(), result));
+
+  // Kick off the next read.
+  ReadNextChunk();

[mtomasz, 2015/02/02 23:47:07]

For large files we will keep the IO thread busy for number of seconds. IIRC this
thread is shared with IPC. While occupying IO thread is not as bad as UI, it may
cause unresponsiveness of the browser. Please check with huge files if browser
is still responsive. IIf it's fine, then let's go with the current solution. If
it's not, then we may want to use a blocking thread pool.

[Ben Kwa, 2015/02/03 16:32:19]

Will investigate this today and update with what I find.

+}
+
 std::string GetHostedDocumentExtension(const std::string& mime_type) {
   for (size_t i = 0; i < arraysize(kHostedDocumentKinds); ++i) {
     if (mime_type == kHostedDocumentKinds[i].mime_type)
       return kHostedDocumentKinds[i].extension;
   }
   return kUnknownHostedDocumentExtension;
 }
 
 bool IsKnownHostedDocumentMimeType(const std::string& mime_type) {
   for (size_t i = 0; i < arraysize(kHostedDocumentKinds); ++i) {
     if (mime_type == kHostedDocumentKinds[i].mime_type)
       return true;
   }
   return false;
 }
 
 bool HasHostedDocumentExtension(const base::FilePath& path) {
   const std::string extension = base::FilePath(path.Extension()).AsUTF8Unsafe();
   for (size_t i = 0; i < arraysize(kHostedDocumentKinds); ++i) {
     if (extension == kHostedDocumentKinds[i].extension)
       return true;
   }
   return extension == kUnknownHostedDocumentExtension;
 }
 
 }  // namespace util
 }  // namespace drive