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;
 };
 
 const HostedDocumentKind kHostedDocumentKinds[] = {
     {kGoogleDocumentMimeType,     ".gdoc"},
     {kGoogleSpreadsheetMimeType,  ".gsheet"},
     {kGooglePresentationMimeType, ".gslides"},
     {kGoogleDrawingMimeType,      ".gdraw"},
     {kGoogleTableMimeType,        ".gtable"},
     {kGoogleFormMimeType,         ".gform"},
     {kGoogleMapMimeType,          ".gmaps"},
 };
 
 const char kUnknownHostedDocumentExtension[] = ".glink";
 
+const int kMd5DigestBufferSize = 512 * 1024;  // 512 kB.
+
 }  // namespace
 
 std::string EscapeQueryStringValue(const std::string& str) {
   std::string result;
   result.reserve(str.size());
   for (size_t i = 0; i < str.size(); ++i) {
     if (str[i] == '\\' || str[i] == '\'') {
       result.push_back('\\');
     }
     result.push_back(str[i]);
@@ skipping 71 matching lines @@
   // If resource ID is in the old WAPI format starting with a prefix like
   // "document:", strip it and return the remaining part.
   std::string stripped_resource_id;
   if (RE2::FullMatch(resource_id, "^[a-z-]+(?::|%3A)([\\w-]+)$",
                      &stripped_resource_id))
     return stripped_resource_id;
   return resource_id;
 }
 
 std::string GetMd5Digest(const base::FilePath& file_path) {
-  const int kBufferSize = 512 * 1024;  // 512kB.
-
   base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!file.IsValid())
     return std::string();
 
   base::MD5Context context;
   base::MD5Init(&context);
 
   int64 offset = 0;
-  scoped_ptr<char[]> buffer(new char[kBufferSize]);
+  scoped_ptr<char[]> buffer(new char[kMd5DigestBufferSize]);
   while (true) {
-    int result = file.Read(offset, buffer.get(), kBufferSize);
+    int result = file.Read(offset, buffer.get(), kMd5DigestBufferSize);
     if (result < 0) {
       // Found an error.
       return std::string();
     }
 
     if (result == 0) {
       // End of file.
       break;
     }
 
     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(kMd5DigestBufferSize)) {
+}
+
+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(), kMd5DigestBufferSize,
+      base::Bind(&FileStreamMd5Digester::OnChunkRead, base::Unretained(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();
+}
+
 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