Added member data to classes to support download resumption.

content/browser/download/base_file.h

 // Copyright (c) 2011 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_BASE_FILE_H_
 #define CONTENT_BROWSER_DOWNLOAD_BASE_FILE_H_
 #pragma once
 
 #include <string>
 
@@ skipping 16 matching lines @@
 }
 
 // File being downloaded and saved to disk. This is a base class
 // for DownloadFile and SaveFile, which keep more state information.
 class CONTENT_EXPORT BaseFile {
  public:
   BaseFile(const FilePath& full_path,
            const GURL& source_url,
            const GURL& referrer_url,
            int64 received_bytes,
+           bool calculate_hash,
+           const std::string& hash_state,
            const linked_ptr<net::FileStream>& file_stream);
   virtual ~BaseFile();
 
-  // If calculate_hash is true, sha256 hash will be calculated.
   // Returns net::OK on success, or a network error code on failure.
-  net::Error Initialize(bool calculate_hash);
+  net::Error Initialize();
 
   // Write a new chunk of data to the file.
   // Returns net::OK on success (all bytes written to the file),
   // or a network error code on failure.
   net::Error AppendDataToFile(const char* data, size_t data_len);
 
   // Rename the download file.
   // Returns net::OK on success, or a network error code on failure.
   virtual net::Error Rename(const FilePath& full_path);
 
   // Detach the file so it is not deleted on destruction.
   virtual void Detach();
 
   // Abort the download and automatically close the file.
   void Cancel();
 
   // Indicate that the download has finished. No new data will be received.
   void Finish();
 
   // Informs the OS that this file came from the internet.
   void AnnotateWithSourceInformation();
 
   // Calculate and return the current speed in bytes per second.
   int64 CurrentSpeed() const;
 
   FilePath full_path() const { return full_path_; }
   bool in_progress() const { return file_stream_ != NULL; }
   int64 bytes_so_far() const { return bytes_so_far_; }
 
-  // Set |hash| with sha256 digest for the file.
+  // Fills |hash| with the sha256 digest for the file.

[Randy Smith (Not in Mondays), 2011/12/20 17:05:40]

Basic question: Is the fact that the hash is an sha256 hash part of the
interface?  I.e. does anything outside of download file and crypto need to know
about it?  If yes, then I'll retract my earlier request that the interfaces not
name the type of hash.  If not, then the comment shouldn't refer to it either.

Now that I ask the question, I'm somewhat afraid that the safebrowsing system
*does* need to know that it's sha256, since it's comparing against stored
hashes.  Which means I was wrong in my initial comment.  But either way, the
comments and interface should be in alignment, and the naming/commenting should
be based on whether external customers need to know what kind of hash it is.  

[ahendrickson, 2011/12/20 22:06:54]

Changed the comments to match the functions.

   // Returns true if digest is successfully calculated.
-  virtual bool GetSha256Hash(std::string* hash);
+  virtual bool GetHash(std::string* hash);
+
+  // Returns the current (intermediate) state of the hash as a byte string.
+  virtual std::string GetHashState();
 
   // Returns true if the given hash is considered empty.  An empty hash is
   // a string of size kSha256HashLen that contains only zeros (initial value
   // for the hash).
-  static bool IsEmptySha256Hash(const std::string& hash);
+  static bool IsEmptyHash(const std::string& hash);
 
   virtual std::string DebugString() const;
 
  protected:
   virtual void CreateFileStream();  // For testing.
   // Returns net::OK on success, or a network error code on failure.
   net::Error Open();
   void Close();
 
   // Full path to the file including the file name.
   FilePath full_path_;
 
  private:
   friend class BaseFileTest;
-  FRIEND_TEST_ALL_PREFIXES(BaseFileTest, IsEmptySha256Hash);
+  FRIEND_TEST_ALL_PREFIXES(BaseFileTest, IsEmptyHash);
 
   // Split out from CurrentSpeed to enable testing.
   int64 CurrentSpeedAtTime(base::TimeTicks current_time) const;
 
+  // Resets the current state of the hash to the contents of |hash_state_bytes|.
+  virtual bool SetHashState(const std::string& hash_state_bytes);
+
   static const size_t kSha256HashLen = 32;
   static const unsigned char kEmptySha256Hash[kSha256HashLen];
 
   // Source URL for the file being downloaded.
   GURL source_url_;
 
   // The URL where the download was initiated.
   GURL referrer_url_;
 
   // OS file stream for writing
@@ skipping 18 matching lines @@
   unsigned char sha256_hash_[kSha256HashLen];
 
   // Indicates that this class no longer owns the associated file, and so
   // won't delete it on destruction.
   bool detached_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseFile);
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_BASE_FILE_H_