Add support to sha256 hash the downloaded file....

chrome/browser/download/base_file.cc

 // Copyright (c) 2010 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/download/base_file.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/third_party/nss/blapi.h"
+#include "base/third_party/nss/sha256.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/download/download_util.h"
 
 #if defined(OS_WIN)
 #include "app/win/win_util.h"
 #include "chrome/common/win_safe_util.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/ui/cocoa/file_metadata.h"
 #endif
 
 BaseFile::BaseFile(const FilePath& full_path,
                    const GURL& source_url,
                    const GURL& referrer_url,
                    int64 received_bytes,
-                   const linked_ptr<net::FileStream>& file_stream)
+                   const linked_ptr<net::FileStream>& file_stream,
+                   bool calculate_hash)
     : full_path_(full_path),
       path_renamed_(false),
       source_url_(source_url),
       referrer_url_(referrer_url),
       file_stream_(file_stream),
       bytes_so_far_(received_bytes),
-      power_save_blocker_(true) {
+      power_save_blocker_(true),
+      calculate_hash_(calculate_hash),
+      sha_context_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 BaseFile::~BaseFile() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (in_progress())
     Cancel();
   Close();
 }
 
 bool BaseFile::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  if (calculate_hash_) {
+    sha_context_.reset(new SHA256Context);
+    SHA256_Begin(sha_context_.get());
+  }
+
   if (!full_path_.empty() ||
       download_util::CreateTemporaryFileForDownload(&full_path_))
     return Open();
   return false;
 }
 
 bool BaseFile::AppendDataToFile(const char* data, size_t data_len) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!file_stream_.get())
     return false;
 
   // TODO(phajdan.jr): get rid of this check.
   if (data_len == 0)
     return true;
 
+  if (calculate_hash_) {
+    SHA256_Update(sha_context_.get(),

[Paweł Hajdan Jr., 2011/01/11 08:28:21]

Hmm, I wonder if we should somehow check result of file_stream_->Write below. If
that one fails, the calculated hash will get out of sync with real contents on
disk.

[lzheng, 2011/01/12 02:11:54]

Done.

+                  reinterpret_cast<const unsigned char*>(data),
+                  data_len);
+  }
+
   bytes_so_far_ += data_len;
 
   // TODO(phajdan.jr): handle errors on file writes. http://crbug.com/58355
   size_t written = file_stream_->Write(data, data_len, NULL);
   return (written == data_len);
 }
 
 bool BaseFile::Rename(const FilePath& new_path, bool is_final_rename) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
@@ skipping 61 matching lines @@
 void BaseFile::Cancel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Close();
   if (!full_path_.empty())
     file_util::Delete(full_path_, false);
 }
 
 void BaseFile::Finish() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Close();
+  if (calculate_hash_) {
+    SHA256_End(sha_context_.get(), sha256_hash_, NULL, kSha256HashLen_);
+  }
+}
+
+bool BaseFile::GetSha256Hash(std::string* hash) {
+  if (!calculate_hash_)
+    return false;
+  *hash =
+      StringToLowerASCII(base::HexEncode(sha256_hash_, sizeof(sha256_hash_)));

[Randy Smith (Not in Mondays), 2011/01/11 18:29:51]

This means that the hash can be grabbed at any time during the download process,
and it'll be the hash to this point but not completed?  That seems like not what
you'd like; wouldn't you prefer GetSha256Hash to return false if the downloading
hasn't yet completed?

+  return true;
 }
 
 void BaseFile::AnnotateWithSourceInformation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 #if defined(OS_WIN)
   // Sets the Zone to tell Windows that this file comes from the internet.
   // We ignore the return value because a failure is not fatal.
   win_util::SetInternetZoneIdentifier(full_path_);
 #elif defined(OS_MACOSX)
   file_metadata::AddQuarantineMetadataToFile(full_path_, source_url_,
@@ skipping 42 matching lines @@
     file_stream_->Close();
     file_stream_.reset();
   }
 }
 
 std::string BaseFile::DebugString() const {
   return base::StringPrintf("{ source_url_ = \"%s\" full_path_ = \"%s\" }",
                             source_url_.spec().c_str(),
                             full_path_.value().c_str());
 }