Add LocalFileChangeTracker database to record non-synced dirty files

webkit/fileapi/syncable/local_file_change_tracker_unittest.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 "webkit/fileapi/syncable/local_file_change_tracker.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
+#include "base/scoped_temp_dir.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/local_file_sync_status.h"
 
 namespace fileapi {
 
 namespace {
 
 // Test URLs (no parent/child relationships, as we test such cases
 // mainly in LocalFileSyncStatusTest).
 const char kURL0[] = "filesystem:http://foo.com/test/dir a/file";
 const char kURL1[] = "filesystem:http://foo.com/test/dir b";
 const char kURL2[] = "filesystem:http://foo.com/test/foo.txt";
 const char kURL3[] = "filesystem:http://foo.com/test/bar";
 const char kURL4[] = "filesystem:http://foo.com/temporary/dir a";
 
+const char kExternalFileSystemID[] = "drive";
+
 FileSystemURL URL(const char* spec) {
   return FileSystemURL(GURL(spec));
 }
 
 }  // namespace
 
 class LocalFileChangeTrackerTest : public testing::Test {
  public:
   LocalFileChangeTrackerTest()
-      : sync_status_(new LocalFileSyncStatus),
-        change_tracker_(new LocalFileChangeTracker(
-            sync_status_.get(), base::MessageLoopProxy::current())) {}
+      : sync_status_(new LocalFileSyncStatus) {}
+
+  virtual void SetUp() OVERRIDE {
+    EXPECT_TRUE(data_dir_.CreateUniqueTempDir());
+    change_tracker_.reset(new LocalFileChangeTracker(
+        sync_status_.get(),
+        data_dir_.path(),
+        base::MessageLoopProxy::current()));
+    IsolatedContext::GetInstance()->RegisterExternalFileSystem(
+        kExternalFileSystemID,
+        kFileSystemTypeSyncable,
+        FilePath());
+  }
 
  protected:
   LocalFileSyncStatus* sync_status() const {
     return sync_status_.get();
   }
 
   LocalFileChangeTracker* change_tracker() const {
     return change_tracker_.get();
   }
 
+  std::string SerializeExternalFileSystemURL(const FileSystemURL& url) {
+    return change_tracker_->SerializeExternalFileSystemURL(url);
+  }
+
+  FileSystemURL DeserializeExternalFileSystemURL(const std::string& url) {
+    return change_tracker_->DeserializeExternalFileSystemURL(url);
+  }
+
   void VerifyChange(const FileSystemURL& url,
                     const FileChange& expected_change) {
     SCOPED_TRACE(testing::Message() << url.spec() <<
                  " expecting:" << expected_change.DebugString());
     // Writes need to be disabled before calling GetChangesForURL().
     ASSERT_TRUE(sync_status()->TryDisableWriting(url));
 
     // Get the changes for URL and verify.
     FileChangeList changes;
     change_tracker()->GetChangesForURL(url, &changes);
     SCOPED_TRACE(testing::Message() << url.spec() <<
                  " actual:" << changes.DebugString());
     EXPECT_EQ(1U, changes.size());
     EXPECT_EQ(expected_change, changes.list()[0]);
 
     // Finish sync for URL to enable writing.
     EXPECT_FALSE(sync_status()->IsWritable(url));
     change_tracker()->FinalizeSyncForURL(url);
     EXPECT_TRUE(sync_status()->IsWritable(url));
 
     // See if the changes for URL are reset.
     ASSERT_TRUE(sync_status()->TryDisableWriting(url));
     change_tracker()->GetChangesForURL(url, &changes);
     EXPECT_TRUE(changes.empty());
   }
 
  private:
+  ScopedTempDir data_dir_;
   MessageLoop message_loop_;
   scoped_ptr<LocalFileSyncStatus> sync_status_;
   scoped_ptr<LocalFileChangeTracker> change_tracker_;
 };
 
 TEST_F(LocalFileChangeTrackerTest, GetChanges) {
   change_tracker()->OnCreateFile(URL(kURL0));
   change_tracker()->OnRemoveFile(URL(kURL0));  // Offset the create.
   change_tracker()->OnRemoveDirectory(URL(kURL1));
   change_tracker()->OnCreateDirectory(URL(kURL2));
@@ skipping 21 matching lines @@
                FileChange(FileChange::FILE_CHANGE_ADD,
                           FileChange::FILE_TYPE_DIRECTORY));
   VerifyChange(URL(kURL3),
                FileChange(FileChange::FILE_CHANGE_DELETE,
                           FileChange::FILE_TYPE_FILE));
   VerifyChange(URL(kURL4),
                FileChange(FileChange::FILE_CHANGE_UPDATE,
                           FileChange::FILE_TYPE_FILE));
 }
 
+TEST_F(LocalFileChangeTrackerTest, SerializeExternalFileSystemURL) {
+  const std::string kFileSystemRootURI = "filesystem:http://foo.com/external/";
+  const std::string kExternalFileSystemURL =
+      kFileSystemRootURI + kExternalFileSystemID + "/dir a/file";
+  FileSystemURL url = FileSystemURL(GURL(kExternalFileSystemURL));

[kinuko, 2012/09/21 08:12:32]

Maybe if this file system gets mature we might add the official public type to
handle this.  It could be a separate bug but how about:
- adding a separate syncable_file_system_util and having following methods:
 * RegisterSyncableFileSystem(origin, service_name /* == mount_name in external
fs internally */)
 * CreateSyncableFileSystemURL(origin, service_name)
 * SerializableSyncableFileSystemURL(url)
 * DeserializeSyncableFileSystemURL(serialized_url, url)

[nhiroki, 2012/09/24 07:01:40]

Okay, I filed it (http://crbug.com/151876), and I'll make a separate patch.

+
+  std::string serialized = SerializeExternalFileSystemURL(url);
+  EXPECT_EQ(kExternalFileSystemURL, serialized);
+  EXPECT_EQ(url, DeserializeExternalFileSystemURL(serialized));
+}
+
+// TODO(nhiroki): add unittests to ensure the database works successfully.
+
 }  // namespace fileapi