Remote service state handling

chrome/browser/sync_file_system/drive_file_sync_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_FILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_FILE_SYNC_SERVICE_H_
 
 #include <deque>
 #include <map>
 #include <queue>
@@ skipping 90 matching lines @@
 
   struct RemoteChangeComparator {
     bool operator()(const RemoteChange& left, const RemoteChange& right);
   };
 
   typedef std::priority_queue<RemoteChange, std::vector<RemoteChange>,
                               RemoteChangeComparator> ChangeQueue;
   typedef std::map<FilePath, int64> PathToChangeStamp;
   typedef std::map<GURL, PathToChangeStamp> ChangeStampMap;
 
+  // Task types; used for task token handling.
+  enum TaskType {
+    // No task is holding this token.
+    TASK_TYPE_NONE,
+
+    // Token is granted for drive-related async task.
+    TASK_TYPE_DRIVE,
+
+    // Token is granted for async database task.
+    TASK_TYPE_DATABASE,
+  };
+
   DriveFileSyncService(scoped_ptr<DriveFileSyncClient> sync_client,
                        scoped_ptr<DriveMetadataStore> metadata_store);
 
-  scoped_ptr<TaskToken> GetToken(const tracked_objects::Location& from_here);
+  // This should be called when an async task needs to get a task token.
+  // |task_description| is optional but should give human-readable
+  // messages that describe the task that is acquiring the token.
+  scoped_ptr<TaskToken> GetToken(const tracked_objects::Location& from_here,
+                                 TaskType task_type,
+                                 const std::string& task_description);
   void NotifyTaskDone(fileapi::SyncStatusCode status,
                       scoped_ptr<TaskToken> token);
+  void UpdateServiceState();
 
   void DidInitializeMetadataStore(scoped_ptr<TaskToken> token,
                                   fileapi::SyncStatusCode status,
                                   bool created);
   void DidGetSyncRootDirectory(scoped_ptr<TaskToken> token,
                                google_apis::GDataErrorCode error,
                                const std::string& resource_id);
   void StartBatchSyncForOrigin(const GURL& origin,
                                const std::string& resource_id);
   void DidGetDirectoryForOrigin(scoped_ptr<TaskToken> token,
@@ skipping 22 matching lines @@
                              google_apis::DocumentEntry* entry,
                              int64 changestamp);
   void DidGetBatchSyncListData(scoped_ptr<TaskToken> token,
                                const GURL& origin,
                                google_apis::GDataErrorCode error,
                                scoped_ptr<base::Value> data);
 
   scoped_ptr<DriveMetadataStore> metadata_store_;
   scoped_ptr<DriveFileSyncClient> sync_client_;
 
-  fileapi::SyncStatusCode status_;
+  fileapi::SyncStatusCode last_operation_status_;
+  RemoteServiceState state_;
   std::deque<base::Closure> pending_tasks_;
 
   int64 largest_changestamp_;
   ChangeQueue pending_changes_;
   ChangeStampMap changestamp_map_;
 
   // Absence of |token_| implies a task is running. Incoming tasks should
   // wait for the task to finish in |pending_tasks_| if |token_| is null.
   // Each task must take TaskToken instance from |token_| and must hold it
   // until it finished. And the task must return the instance through
   // NotifyTaskDone when the task finished.
   scoped_ptr<TaskToken> token_;
 
   ObserverList<Observer> observers_;
   base::WeakPtrFactory<DriveFileSyncService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveFileSyncService);
 };
 
 }  // namespace sync_file_system
 
 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_FILE_SYNC_SERVICE_H_