drive: Add "Delta Update Status" section to chrome:drive-internals

chrome/browser/chromeos/drive/drive_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/drive/drive_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop_proxy.h"
@@ skipping 326 matching lines @@
     google_apis::DriveServiceInterface* drive_service,
     google_apis::DriveUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
       drive_service_(drive_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
+      last_update_check_error_(DRIVE_FILE_OK),
       hide_hosted_docs_(false),
       blocking_task_runner_(blocking_task_runner),
       scheduler_(new DriveScheduler(profile, &drive_operations_)),
+      polling_interval_sec_(kFastPollingIntervalInSec),
+      push_notification_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ui_weak_ptr_factory_(this)),
-      ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()),
-      polling_interval_sec_(kFastPollingIntervalInSec) {
+      ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void DriveFileSystem::Reload() {
   InitializeResourceMetadataAndFeedLoader();
 
   feed_loader_->ReloadFromServerIfNeeded(
       base::Bind(&DriveFileSystem::NotifyInitialLoadFinishedAndRun,
                  ui_weak_ptr_,
@@ skipping 41 matching lines @@
 
   if (resource_metadata_->initialized() && !feed_loader_->refreshing()) {
     feed_loader_->ReloadFromServerIfNeeded(
         base::Bind(&DriveFileSystem::OnUpdateChecked, ui_weak_ptr_));
   }
 }
 
 void DriveFileSystem::OnUpdateChecked(DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "CheckForUpdates finished: " << error;
+  last_update_check_time_ = base::Time::Now();
+  last_update_check_error_ = error;
 }
 
 DriveFileSystem::~DriveFileSystem() {
   // This should be called from UI thread, from DriveSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->RemoveObserver(this);
 
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
@@ skipping 41 matching lines @@
   // DriveSystemService::RemoveDriveMountPoint(), this will be called again from
   // FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread().
   // We choose to stopping updates asynchronous without waiting for filemanager,
   // rather than waiting for completion of unmounting on filemanager.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (update_timer_.IsRunning())
     update_timer_.Stop();
 }
 
 void DriveFileSystem::SetPushNotificationEnabled(bool enabled) {
+  push_notification_enabled_ = enabled;
   polling_interval_sec_ = enabled ? kSlowPollingIntervalInSec :
                           kFastPollingIntervalInSec;
 }
 
 void DriveFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
@@ skipping 1647 matching lines @@
                                      params.callback));
 }
 
 DriveFileSystemMetadata DriveFileSystem::GetMetadata() const {
   DriveFileSystemMetadata metadata;
   metadata.largest_changestamp = resource_metadata_->largest_changestamp();
   metadata.origin = resource_metadata_->initialized() ?
       "INITIALIZED" : "UNINITIALIZED";
   if (feed_loader_->refreshing())
     metadata.origin += " (refreshing)";
+
+  // Metadata related to delta update.
+  metadata.push_notification_enabled = push_notification_enabled_;
+  metadata.polling_interval_sec = polling_interval_sec_;
+  metadata.last_update_check_time = last_update_check_time_;
+  metadata.last_update_check_error = last_update_check_error_;
+
   return metadata;
 }
 
 void DriveFileSystem::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     PrefService* pref_service = profile_->GetPrefs();
@@ skipping 351 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace drive