Add OnSyncEnabled/OnWriteEnabled notification handling to operation runner

webkit/fileapi/syncable/syncable_file_operation_runner_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 "base/basictypes.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/blob/mock_blob_url_request_context.h"
@@ skipping 57 matching lines @@
 
     file_system_.TearDown();
     message_loop_.RunAllPending();
     RevokeSyncableFileSystem(kServiceName);
   }
 
   FileSystemURL URL(const std::string& path) {
     return file_system_.URL(path);
   }
 
-  LocalFileSyncContext* sync_context() {
-    return file_system_.file_system_context()->sync_context();
-  }
-
-  SyncableFileOperationRunner* operation_runner() {
-    return sync_context()->operation_runner().get();
-  }
-
   LocalFileSyncStatus* sync_status() {
-    return operation_runner()->sync_status();
+    return file_system_.file_system_context()->sync_context()->sync_status();
   }
 
   void ResetCallbackStatus() {
     write_status_ = base::PLATFORM_FILE_ERROR_FAILED;
     write_bytes_ = 0;
     write_complete_ = false;
     callback_count_ = 0;
   }
 
   StatusCallback ExpectStatus(const tracked_objects::Location& location,
@@ skipping 59 matching lines @@
   file_system_.NewOperation()->FileExists(
       URL(kFile), ExpectStatus(FROM_HERE, base::PLATFORM_FILE_ERROR_NOT_FOUND));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 
   // End syncing (to enable write).
   sync_status()->EndSyncing(URL(kFile));
   ASSERT_TRUE(sync_status()->IsWritable(URL(kFile)));
 
   ResetCallbackStatus();
-  operation_runner()->RunNextRunnableTask();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(2, callback_count_);
 
   // Now the file must have been created and updated.
   ResetCallbackStatus();
   file_system_.NewOperation()->FileExists(
       URL(kFile), ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 }
 
 TEST_F(SyncableFileOperationRunnerTest, WriteToParentAndChild) {
   // First create the kDir directory and kChild in the dir.
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_.CreateDirectory(URL(kDir)));
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_.CreateFile(URL(kChild)));
 
   // Start syncing the kDir directory.
   sync_status()->StartSyncing(URL(kDir));
   ASSERT_FALSE(sync_status()->IsWritable(URL(kDir)));
 
-  // Writes to kParent, kDir and kChild should be all queued up.
+  // Writes to kParent and kChild should be all queued up.
   ResetCallbackStatus();
   file_system_.NewOperation()->Truncate(
       URL(kChild), 1, ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   file_system_.NewOperation()->Remove(
-      URL(kDir), true /* recursive */,
-      ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
-  file_system_.NewOperation()->Remove(
       URL(kParent), true /* recursive */,
       ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, callback_count_);
 
   // Read operations are not blocked (and are executed before queued ones).
   file_system_.NewOperation()->DirectoryExists(
       URL(kDir), ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 
   // Writes to unrelated files must succeed as well.
   ResetCallbackStatus();
   file_system_.NewOperation()->CreateDirectory(
       URL(kOther), false /* exclusive */, false /* recursive */,
       ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 
   // End syncing (to enable write).
   sync_status()->EndSyncing(URL(kDir));
   ASSERT_TRUE(sync_status()->IsWritable(URL(kDir)));
 
   ResetCallbackStatus();
-  operation_runner()->RunNextRunnableTask();
   MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(3, callback_count_);
+  EXPECT_EQ(2, callback_count_);
 }
 
 TEST_F(SyncableFileOperationRunnerTest, CopyAndMove) {
   // First create the kDir directory and kChild in the dir.
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_.CreateDirectory(URL(kDir)));
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_.CreateFile(URL(kChild)));
 
   // Start syncing the kParent directory.
   sync_status()->StartSyncing(URL(kParent));
 
@@ skipping 22 matching lines @@
   ResetCallbackStatus();
   file_system_.NewOperation()->Copy(
       URL(kDir), URL("dest-copy2"),
       ExpectStatus(FROM_HERE, base::PLATFORM_FILE_OK));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, callback_count_);
 
   // Finish syncing the "dest-copy2" directory to unlock Copy.
   sync_status()->EndSyncing(URL("dest-copy2"));
   ResetCallbackStatus();
-  operation_runner()->RunNextRunnableTask();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 
   // Now we should have "dest-copy2".
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             file_system_.DirectoryExists(URL("dest-copy2")));
 
   // Finish syncing the kParent to unlock Move.
   sync_status()->EndSyncing(URL(kParent));
   ResetCallbackStatus();
-  operation_runner()->RunNextRunnableTask();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, callback_count_);
 
   // Now we should have "dest-move".
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             file_system_.DirectoryExists(URL("dest-move")));
 }
 
 TEST_F(SyncableFileOperationRunnerTest, Write) {
   EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_.CreateFile(URL(kFile)));
   const GURL kBlobURL("blob:foo");
   const std::string kData("Lorem ipsum.");
   ScopedTextBlob blob(url_request_context_, kBlobURL, kData);
 
   sync_status()->StartSyncing(URL(kFile));
 
   ResetCallbackStatus();
   file_system_.NewOperation()->Write(
       &url_request_context_,
       URL(kFile), kBlobURL, 0, GetWriteCallback(FROM_HERE));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, callback_count_);
 
   sync_status()->EndSyncing(URL(kFile));
   ResetCallbackStatus();
-  operation_runner()->RunNextRunnableTask();
 
   while (!write_complete_)
     MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, write_status_);
   EXPECT_EQ(kData.size(), write_bytes_);
   EXPECT_TRUE(write_complete_);
 }
 
 TEST_F(SyncableFileOperationRunnerTest, QueueAndCancel) {
@@ skipping 13 matching lines @@
   ResetCallbackStatus();
 
   // This shouldn't crash nor leak memory.
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(2, callback_count_);
 }
 
 }  // namespace fileapi