gdata: Implement periodic file system update checks.

chrome/browser/chromeos/gdata/gdata_file_system.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 "chrome/browser/chromeos/gdata/gdata_file_system.h"
 
 #include <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 59 matching lines @@
 const FilePath::CharType kGDataCacheTmpDownloadsDir[] =
     FILE_PATH_LITERAL("tmp/downloads");
 const FilePath::CharType kGDataCacheTmpDocumentsDir[] =
     FILE_PATH_LITERAL("tmp/documents");
 const FilePath::CharType kAccountMetadataFile[] =
     FILE_PATH_LITERAL("account_metadata.json");
 const FilePath::CharType kFilesystemProtoFile[] =
     FILE_PATH_LITERAL("file_system.pb");
 const FilePath::CharType kSymLinkToDevNull[] = FILE_PATH_LITERAL("/dev/null");
 
+// GData update check interval (in seconds).
+#ifndef NDEBUG
+const int kGDataUpdateCheckIntervalInSec = 5;
+#else
+const int kGDataUpdateCheckIntervalInSec = 60;
+#endif
+
 // Schedule for dumping root file system proto buffers to disk depending its
 // total protobuffer size in MB.
 typedef struct {
   double size;
   int timeout;
 } SerializationTimetable;
 
 SerializationTimetable kSerializeTimetable[] = {
 #ifndef NDEBUG
     {0.5, 0},    // Less than 0.5MB, dump immediately.
@@ skipping 831 matching lines @@
 // GDataFileSystem class implementatsion.
 
 GDataFileSystem::GDataFileSystem(Profile* profile,
                                  DocumentsServiceInterface* documents_service)
     : profile_(profile),
       documents_service_(documents_service),
       on_io_completed_(new base::WaitableEvent(
           true /* manual reset */, true /* initially signaled */)),
       cache_initialization_started_(false),
       num_pending_tasks_(0),
+      num_file_watches_(0),
       hide_hosted_docs_(false),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(
           new base::WeakPtrFactory<GDataFileSystem>(this))),
       ui_weak_ptr_(ui_weak_ptr_factory_->GetWeakPtr()),
       sequence_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
@@ skipping 13 matching lines @@
   documents_service_->Initialize(profile_);
 
   root_.reset(new GDataRootDirectory);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
+void GDataFileSystem::CheckForUpdates() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ContentOrigin initial_origin = root_->origin();
+  if (initial_origin == FROM_SERVER) {
+    root_->set_origin(REFRESHING);
+    ReloadFeedFromServerIfNeeded(initial_origin,
+                                 root_->largest_changestamp(),
+                                 root_->GetFilePath(),
+                                 gdata::FindEntryCallback());
+  }
+}
+
 bool GDataFileSystem::SetCacheRootPathForTesting(const FilePath& root_path) {
   if (cache_initialization_started_)
     return false;
   cache_paths_.clear();
   SetCachePaths(root_path);
   return true;
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
@@ skipping 35 matching lines @@
 }
 
 void GDataFileSystem::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void GDataFileSystem::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void GDataFileSystem::AddFileWatch(const FilePath&) {
+  // Perform an immediate check for updates.
+  CheckForUpdates();
+  // Start timer to periodically check for updates at the given intervals.
+  if (!(num_file_watches_++)) {

[satorux1, 2012/05/03 16:49:29]

This looks tricky. maybe:

++num_file_watches_;
if (num_file_watches_ == 1) {  // first time.

[hshi, 2012/05/03 17:46:35]

Done.

+    file_watch_timer_.Start(FROM_HERE,
+                            base::TimeDelta::FromSeconds(
+                                kGDataUpdateCheckIntervalInSec),
+                            this, &GDataFileSystem::CheckForUpdates);

[zel, 2012/05/03 03:41:07]

this should be ui_weak_ptr_ instead of 'this'

[satorux1, 2012/05/03 16:49:29]

Looking at base/timer.h, there is another Start() method that takes a callback
rather than |this| + |method|. Can you use that version instead?

[hshi, 2012/05/03 17:46:35]

Zel & Satoru, the documentation in base/timer.h actually recommends to pass the
"this" pointer directly to base::RepeatingTimer.Start(). This is also how this
is invoked in many other places.

The definition of BaseTimerMethodPointer::Start already handles the binding of
the method and the "this" pointer as a non-refcounted class:

  void Start(const tracked_objects::Location& posted_from,
             TimeDelta delay,
             Receiver* receiver,
             ReceiverMethod method) {
    Timer::Start(posted_from, delay,
                 base::Bind(method, base::Unretained(receiver)));
  }

[satorux1, 2012/05/03 18:09:29]

This is worrisome. Is this safe? I don't know how Timer classes are implemented,
so this may be safe, but asynchronous API that takes raw |this| pointer is
scary.

Generally we avoid using base::Unretained(this) as a bad thing (use-after-free)
happens if the callback is run after |this| object is deleted.

If we can pass base::Bind(method, weak_ptr_ui) instead of |this| + |method|,
it'd be safer.

+  }
+}
+
+void GDataFileSystem::RemoveFileWatch(const FilePath&) {
+  if (num_file_watches_ <= 0) {
+    NOTREACHED();
+  } else if (!(--num_file_watches_)) {

[satorux1, 2012/05/03 16:49:29]

This also looks tricky. maybe 

else {
  --num_file_watches_;
  if (num_file_watches_ == 0) {

[hshi, 2012/05/03 17:46:35]

Done.

+    file_watch_timer_.Stop();
+  }
+}
+
 void GDataFileSystem::Authenticate(const AuthStatusCallback& callback) {
   // TokenFetcher, used in DocumentsService, must be run on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Authenticate(callback);
 }
 
 void GDataFileSystem::FindEntryByResourceIdSync(
     const std::string& resource_id,
     FindEntryDelegate* delegate) {
@@ skipping 30 matching lines @@
                    callback)));
     return;
   } else if (root_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     root_->set_origin(INITIALIZING);
     LoadRootFeedFromCache(true,  // should_load_from_server
                           search_file_path,
                           callback);
     return;
-  } else if (root_->NeedsRefresh()) {
-    // If content is stale or from disk from cache, fetch content from
-    // the server.
-    ContentOrigin initial_origin = root_->origin();
-    root_->set_origin(REFRESHING);
-    ReloadFeedFromServerIfNeeded(initial_origin,
-                                 root_->largest_changestamp(),
-                                 search_file_path,
-                                 callback);
-    return;
   }
 
   // Post a task to the same thread, rather than calling it here, as
   // FindEntryByPathAsync() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                  ui_weak_ptr_,
                  search_file_path,
                  callback));
@@ skipping 3682 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata