Media Galleries API Picasa: Add file watch to invalidate database data on disk write.

chrome/common/media_galleries/pmp_test_helper.cc

 // Copyright 2013 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/common/media_galleries/pmp_test_helper.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/file_util.h"
@@ skipping 40 matching lines @@
 
   return total;
 }
 
 }  // namespace
 
 PmpTestHelper::PmpTestHelper(const std::string& table_name)
     : table_name_(table_name) {
 }
 
-bool PmpTestHelper::Init() {
-  if (!temp_dir_.CreateUniqueTempDir() || !temp_dir_.IsValid())
+bool PmpTestHelper::Init(ColumnFileDestination column_file_destination) {
+  if (!root_dir_.CreateUniqueTempDir() ||
+      !root_dir_.IsValid() ||
+      !file_util::CreateDirectory(GetDatabaseDirPath()) ||
+      !file_util::CreateDirectory(GetTempDirPath())) {
     return false;
+  }
 
-  base::FilePath indicator_path = temp_dir_.path().Append(
+  if (column_file_destination == DATABASE_DIRECTORY)
+    column_file_destination_directory_ = GetDatabaseDirPath();
+  else if (column_file_destination == TEMPORARY_DIRECTORY)
+    column_file_destination_directory_ = GetTempDirPath();
+  else
+    NOTREACHED();
+
+  base::FilePath indicator_path = column_file_destination_directory_.Append(
       base::FilePath::FromUTF8Unsafe(table_name_ + "_0"));
 
   return file_util::WriteFile(indicator_path, NULL, 0) == 0;
 }
 
-base::FilePath PmpTestHelper::GetTempDirPath() {
-  DCHECK(temp_dir_.IsValid());
-  return temp_dir_.path();
+base::FilePath PmpTestHelper::GetDatabaseDirPath() const {
+  DCHECK(root_dir_.IsValid());
+  return root_dir_.path().AppendASCII(kPicasaDatabaseDirName);
+}
+
+base::FilePath PmpTestHelper::GetTempDirPath() const {
+  DCHECK(root_dir_.IsValid());
+  return root_dir_.path().AppendASCII(kPicasaTempDirName);
 }
 
 template<class T>
 bool PmpTestHelper::WriteColumnFileFromVector(
     const std::string& column_name, const PmpFieldType field_type,
-    const std::vector<T>& elements_vector) {
-  DCHECK(temp_dir_.IsValid());
-
+    const std::vector<T>& elements_vector) const {
   std::string file_name = table_name_ + "_" + column_name + "." + kPmpExtension;
 
-  base::FilePath path = temp_dir_.path().Append(
-      base::FilePath::FromUTF8Unsafe(file_name));
+  base::FilePath path =
+      column_file_destination_directory_.AppendASCII(file_name);
 
   std::vector<char> data = PmpTestHelper::MakeHeaderAndBody(
       field_type, elements_vector.size(), elements_vector);
 
   size_t bytes_written = file_util::WriteFile(path, &data[0], data.size());
   return (bytes_written == data.size());
 }
 
 // Explicit Instantiation for all the valid types.
 template bool PmpTestHelper::WriteColumnFileFromVector<std::string>(
-    const std::string&, const PmpFieldType, const std::vector<std::string>&);
+    const std::string&, const PmpFieldType,
+    const std::vector<std::string>&) const;
 template bool PmpTestHelper::WriteColumnFileFromVector<uint32>(
-    const std::string&, const PmpFieldType, const std::vector<uint32>&);
+    const std::string&, const PmpFieldType, const std::vector<uint32>&) const;
 template bool PmpTestHelper::WriteColumnFileFromVector<double>(
-    const std::string&, const PmpFieldType, const std::vector<double>&);
+    const std::string&, const PmpFieldType, const std::vector<double>&) const;
 template bool PmpTestHelper::WriteColumnFileFromVector<uint8>(
-    const std::string&, const PmpFieldType, const std::vector<uint8>&);
+    const std::string&, const PmpFieldType, const std::vector<uint8>&) const;
 template bool PmpTestHelper::WriteColumnFileFromVector<uint64>(
-    const std::string&, const PmpFieldType, const std::vector<uint64>&);
+    const std::string&, const PmpFieldType, const std::vector<uint64>&) const;
 
 // Return a vector so we don't have to worry about memory management.
 std::vector<char> PmpTestHelper::MakeHeader(const PmpFieldType field_type,
                                             const uint32 row_count) {
   std::vector<char> header(picasa::kPmpHeaderSize);
 
   // Copy in magic bytes.
   memcpy(&header[picasa::kPmpMagic1Offset], &picasa::kPmpMagic1,
          sizeof(picasa::kPmpMagic1));
   memcpy(&header[picasa::kPmpMagic2Offset], &picasa::kPmpMagic2,
@@ skipping 30 matching lines @@
 template std::vector<char> PmpTestHelper::MakeHeaderAndBody<uint32>(
     const PmpFieldType, const uint32, const std::vector<uint32>&);
 template std::vector<char> PmpTestHelper::MakeHeaderAndBody<double>(
     const PmpFieldType, const uint32, const std::vector<double>&);
 template std::vector<char> PmpTestHelper::MakeHeaderAndBody<uint8>(
     const PmpFieldType, const uint32, const std::vector<uint8>&);
 template std::vector<char> PmpTestHelper::MakeHeaderAndBody<uint64>(
     const PmpFieldType, const uint32, const std::vector<uint64>&);
 
 }  // namespace picasa