SafeBrowising: Read and write V4Store from/to disk

components/safe_browsing_db/v4_store.h

 // Copyright 2016 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 COMPONENTS_SAFE_BROWSING_DB_V4_STORE_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_STORE_H_
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "components/safe_browsing_db/v4_protocol_manager_util.h"
 
 namespace safe_browsing {
 
 class V4Store;
 
 typedef base::Callback<void(std::unique_ptr<V4Store>)>
     UpdatedStoreReadyCallback;
 
+// Enumerate different failure events while parsing the file read from disk for
+// histogramming purposes.  DO NOT CHANGE THE ORDERING OF THESE VALUES.
+enum StoreReadFailureType {
+  // Reserved for errors in parsing this enum.

[Nathan Parker, 2016/06/16 00:07:50]

(if this isn't stored in a proto, it probably won't have a parse error, but this
is a good general practice imho)

[vakh (use Gerrit instead), 2016/06/16 08:25:18]

Acknowledged.

+  UNEXPECTED_FAILURE = 0,
+
+  // No errors.
+  SUCCESS = 1,
+
+  // The contents of the file could not be read.
+  FILE_UNREADABLE_FAILURE = 2,
+
+  // The file was found to be empty.
+  FILE_EMPTY_FAILURE = 3,
+
+  // The contents of the file could not be interpreted as a valid
+  // V4StoreFileFormat proto.
+  PROTO_PARSING_FAILURE = 4,
+
+  // The magic number didn't match. We're most likely trying to read a file
+  // that doesn't contain hash-prefixes.
+  UNEXPECTED_MAGIC_NUMBER_FAILURE = 5,
+
+  // The version of the file is lower than expected and Chromium doesn't know
+  // how to interpret this file anymore.
+  FILE_VERSION_TOO_LOW_FAILURE = 6,
+
+  // The rest of the file could not be parsed as a ListUpdateResponse protobuf.
+  // The only case when this can happen is if the machine crashed before the
+  // file was fully written to disk.

[Nathan Parker, 2016/06/16 00:07:50]

Or any general corruption on disk, ya?

[vakh (use Gerrit instead), 2016/06/16 08:25:18]

Done.

+  HASH_PREFIX_INFO_MISSING_FAILURE = 7,
+
+  // Memory space for histograms is determined by the max.  ALWAYS
+  // ADD NEW VALUES BEFORE THIS ONE.
+  FORMAT_FAILURE_MAX
+};
+
 // Factory for creating V4Store. Tests implement this factory to create fake
 // stores for testing.
 class V4StoreFactory {
  public:
   virtual ~V4StoreFactory() {}
   virtual V4Store* CreateV4Store(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       const base::FilePath& store_path);
 };
 
 class V4Store {
  public:
   // The |task_runner| is used to ensure that the operations in this file are
   // performed on the correct thread. |store_path| specifies the location on
   // disk for this file.
   V4Store(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
           const base::FilePath& store_path);
   virtual ~V4Store();
 
   const base::FilePath& store_path() const { return store_path_; }
 
   const std::string& state() const { return state_; }
 
+  void Initialize();
+
   void ApplyUpdate(const ListUpdateResponse&,
                    const scoped_refptr<base::SingleThreadTaskRunner>&,
                    UpdatedStoreReadyCallback);
 
   // Reset internal state and delete the backing file.
   virtual bool Reset();
 
   std::string DebugString() const;
 
  protected:
   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::FilePath store_path_;
   std::string state_;
 
  private:
+  // Creates a new store from an existing one when processing an update.
   V4Store(const V4Store& other);
 
+  // Reads the state of the store from the file on disk and returns the reason
+  // for the failure or reports success.
+  StoreReadFailureType ReadFromDisk();
+
+  // Writes the FULL_UPDATE |response| to disk as a V4StoreFileFormat proto.
+  // Returns false if the write fails.
+  bool WriteToDisk(const ListUpdateResponse& response) const;
+
   std::string GetHumanReadableState() const;
+
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromEmptyFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromAbsentFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromInvalidContentsFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromUnexpectedMagicFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromLowVersionFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromNoHashPrefixInfoFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestReadFromNoHashPrefixesFile);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestWriteNoResponseType);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestWritePartialResponseType);
+  FRIEND_TEST_ALL_PREFIXES(V4StoreTest, TestWriteFullResponseType);
 };
 
 inline std::ostream& operator<<(std::ostream& os, const V4Store& store) {
   os << store.DebugString();
   return os;
 }
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_STORE_H_