gdata: Implement periodic file system update checks.

chrome/browser/chromeos/gdata/gdata_file_system.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_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #pragma once
 
 #include <sys/stat.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
+#include "base/timer.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/gdata/find_entry_delegate.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_operation_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_params.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
@@ skipping 137 matching lines @@
   };
 
   // Initializes the object. This function should be called before any
   // other functions.
   virtual void Initialize() = 0;
 
   // Adds and removes the observer.
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;
 
+  // Starts and stops periodic updates.
+  virtual void StartUpdates() = 0;

[satorux1, 2012/05/03 18:46:20]

Please also explain a bit more about these functions. For instance,
StartUpdates() will start periodic updates only if it's not yet started, right? 

Likewise, StopUpdates() stops it only if the number of update requests becomes
zero, right?

that said, RequestStartPeriodicUpdates(), RequestStopPeriodicUpdates() may be
better names.

[hshi, 2012/05/03 19:09:19]

Done. Although I think "Periodic" may be redundant.

[satorux1, 2012/05/03 19:18:36]

Agreed.

+  virtual void StopUpdates() = 0;
+
   // Enum defining origin of a cached file.
   enum CachedFileOrigin {
     CACHED_FILE_FROM_SERVER = 0,
     CACHED_FILE_LOCALLY_MODIFIED,
     CACHED_FILE_MOUNTED,
   };
 
   // Enum defining type of file operation e.g. copy or move, etc.
   // For now, it's used for StoreToCache.
   enum FileOperationType {
@@ skipping 205 matching lines @@
                         public content::NotificationObserver {
  public:
   GDataFileSystem(Profile* profile,
                   DocumentsServiceInterface* documents_service);
   virtual ~GDataFileSystem();
 
   // GDataFileSystem overrides.
   virtual void Initialize() OVERRIDE;
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
+  virtual void StartUpdates() OVERRIDE;
+  virtual void StopUpdates() OVERRIDE;
   virtual void Authenticate(const AuthStatusCallback& callback) OVERRIDE;
   virtual void FindEntryByResourceIdSync(const std::string& resource_id,
                                          FindEntryDelegate* delegate) OVERRIDE;
   virtual void TransferFile(const FilePath& local_file_path,
                             const FilePath& remote_dest_file_path,
                             const FileOperationCallback& callback) OVERRIDE;
   virtual void Copy(const FilePath& src_file_path,
                     const FilePath& dest_file_path,
                     const FileOperationCallback& callback) OVERRIDE;
   virtual void Move(const FilePath& src_file_path,
@@ skipping 883 matching lines @@
                                const std::string& md5,
                                const GetCacheStateCallback& callback);
   void GetAvailableSpaceOnUIThread(const GetAvailableSpaceCallback& callback);
   void SetPinStateOnUIThread(const FilePath& file_path, bool to_pin,
                              const FileOperationCallback& callback);
   void SetMountedStateOnUIThread(
       const FilePath& file_path,
       bool to_mount,
       const SetMountedStateCallback& callback);
 
+  // Checks for updates on the server.
+  void CheckForUpdates();
+
   scoped_ptr<GDataRootDirectory> root_;
 
   // This guards regular states.
   base::Lock lock_;
 
   // The profile hosts the GDataFileSystem via GDataSystemService.
   Profile* profile_;
 
   // The document service for the GDataFileSystem.
   scoped_ptr<DocumentsServiceInterface> documents_service_;
@@ skipping 10 matching lines @@
   scoped_ptr<base::WaitableEvent> on_io_completed_;
 
   // True if cache initialization has started, is in progress or has completed,
   // we only want to initialize cache once.
   bool cache_initialization_started_;
 
   // Number of pending tasks on the blocking thread pool.
   int num_pending_tasks_;
   base::Lock num_pending_tasks_lock_;
 
+  // Number of active update requests.
+  int num_update_requests_;
+
+  // Periodic timer for checking updates.
+  base::RepeatingTimer<GDataFileSystem> update_timer_;
+
   // True if hosted documents should be hidden.
   bool hide_hosted_docs_;
 
   scoped_ptr<PrefChangeRegistrar> pref_registrar_;
 
   // WeakPtrFactory and WeakPtr bound to the UI thread.
   scoped_ptr<base::WeakPtrFactory<GDataFileSystem> > ui_weak_ptr_factory_;
   base::WeakPtr<GDataFileSystem> ui_weak_ptr_;
 
   ObserverList<Observer> observers_;
@@ skipping 18 matching lines @@
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_