Control the frequency of fileBrowserPrivate.onFileTransfersUpdated events.

chrome/browser/chromeos/gdata/gdata_operation_registry.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_operation_registry.h"
 
 #include "base/string_number_conversions.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
+namespace {
+
+const int64 kNotificationFrequencyInMilliseconds = 150;

[zel, 2012/07/31 15:24:50]

even this looks too frequent to me. let's bring it up to 500-1000 ms range

[kinaba, 2012/08/01 02:28:56]

OK, now it's 1000ms.

+
+}  // namespace
+
 namespace gdata {
 
 // static
 std::string GDataOperationRegistry::OperationTypeToString(OperationType type) {
   switch (type) {
     case OPERATION_UPLOAD: return "upload";
     case OPERATION_DOWNLOAD: return "download";
     case OPERATION_OTHER: return "other";
   }
   NOTREACHED();
@@ skipping 108 matching lines @@
     progress_status_.transfer_state = OPERATION_IN_PROGRESS;
     registry_->OnOperationResume(this, &progress_status_);
   }
 }
 
 void GDataOperationRegistry::Operation::NotifyAuthFailed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   registry_->OnOperationAuthFailed();
 }
 
-GDataOperationRegistry::GDataOperationRegistry() {
+GDataOperationRegistry::GDataOperationRegistry()
+    : do_notification_frequency_control_(true) {
   in_flight_operations_.set_check_on_null_data(true);
 }
 
 GDataOperationRegistry::~GDataOperationRegistry() {
   DCHECK(in_flight_operations_.IsEmpty());
 }
 
 void GDataOperationRegistry::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void GDataOperationRegistry::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
+void GDataOperationRegistry::DisableNotificationFrequencyControlForTest() {
+  do_notification_frequency_control_ = false;
+}
+
 void GDataOperationRegistry::CancelAll() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (OperationIDMap::iterator iter(&in_flight_operations_);
        !iter.IsAtEnd();
        iter.Advance()) {
     Operation* operation = iter.GetCurrentValue();
     operation->Cancel();
     // Cancel() may immediately trigger OnOperationFinish and remove the
     // operation from the map, but IDMap is designed to be safe on such remove
@@ skipping 16 matching lines @@
   return false;
 }
 
 void GDataOperationRegistry::OnOperationStart(
     GDataOperationRegistry::Operation* operation,
     OperationID* id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   *id = in_flight_operations_.Add(operation);
   DVLOG(1) << "GDataOperation[" << *id << "] started.";
-  if (IsFileTransferOperation(operation)) {
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnProgressUpdate(GetProgressStatusList()));
-  }
+  if (IsFileTransferOperation(operation))
+    NotifyStatusToObservers();
 }
 
 void GDataOperationRegistry::OnOperationProgress(OperationID id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Operation* operation = in_flight_operations_.Lookup(id);
   DCHECK(operation);
 
   DVLOG(1) << "GDataOperation[" << id << "] "
            << operation->progress_status().DebugString();
-  if (IsFileTransferOperation(operation)) {
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnProgressUpdate(GetProgressStatusList()));
-  }
+  if (IsFileTransferOperation(operation))
+    NotifyStatusToObservers();
 }
 
 void GDataOperationRegistry::OnOperationFinish(OperationID id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Operation* operation = in_flight_operations_.Lookup(id);
   DCHECK(operation);
 
   DVLOG(1) << "GDataOperation[" << id << "] finished.";
-  if (IsFileTransferOperation(operation)) {
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnProgressUpdate(GetProgressStatusList()));
-  }
+  if (IsFileTransferOperation(operation))
+    NotifyStatusToObservers();
   in_flight_operations_.Remove(id);
 }
 
 void GDataOperationRegistry::OnOperationResume(
     GDataOperationRegistry::Operation* operation,
     GDataOperationRegistry::ProgressStatus* new_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Find the corresponding suspended task.
   Operation* suspended = NULL;
@@ skipping 16 matching lines @@
 
   new_status->progress_current = old_status.progress_current;
   new_status->progress_total = old_status.progress_total;
   new_status->start_time = old_status.start_time;
 
   // Remove the old one and initiate the new operation.
   in_flight_operations_.Remove(old_id);
   new_status->operation_id = in_flight_operations_.Add(operation);
   DVLOG(1) << "GDataOperation[" << old_id << " -> " <<
            new_status->operation_id << "] resumed.";
-  if (IsFileTransferOperation(operation)) {
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnProgressUpdate(GetProgressStatusList()));
-  }
+  if (IsFileTransferOperation(operation))
+    NotifyStatusToObservers();
 }
 
 void GDataOperationRegistry::OnOperationSuspend(OperationID id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Operation* operation = in_flight_operations_.Lookup(id);
   DCHECK(operation);
 
   DVLOG(1) << "GDataOperation[" << id << "] suspended.";
-  if (IsFileTransferOperation(operation)) {
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnProgressUpdate(GetProgressStatusList()));
-  }
+  if (IsFileTransferOperation(operation))
+    NotifyStatusToObservers();
 }
 
 void GDataOperationRegistry::OnOperationAuthFailed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "GDataOperation authentication failed.";
   FOR_EACH_OBSERVER(Observer, observer_list_, OnAuthenticationFailed());
 }
 
 bool GDataOperationRegistry::IsFileTransferOperation(
@@ skipping 10 matching lines @@
   for (OperationIDMap::const_iterator iter(&in_flight_operations_);
        !iter.IsAtEnd();
        iter.Advance()) {
     const Operation* operation = iter.GetCurrentValue();
     if (IsFileTransferOperation(operation))
       status_list.push_back(operation->progress_status());
   }
   return status_list;
 }
 
+bool GDataOperationRegistry::ShouldNotifyStatusNow(
+    const ProgressStatusList& list) {
+  if (!do_notification_frequency_control_)
+    return true;
+
+  base::Time now = base::Time::Now();
+
+  // If it is a first event, or some time abnormality is detected, we should
+  // not skip this notification.
+  if (last_notification_.is_null() || now < last_notification_) {
+    last_notification_ = now;
+    return true;
+  }
+
+  // If sufficiently long time has elapsed since the previous event, we should
+  // not skip this notification.
+  if ((now - last_notification_).InMilliseconds() >=
+      kNotificationFrequencyInMilliseconds) {
+    last_notification_ = now;
+    return true;
+  }
+
+  // If important events (OPERATION_STARTED, COMPLETED, or FAILED) are there,
+  // we should not skip this notification.
+  for (size_t i = 0; i < list.size(); ++i) {
+    if (list[i].transfer_state != OPERATION_IN_PROGRESS) {
+      last_notification_ = now;
+      return true;
+    }
+  }
+
+  // Otherwise we can skip it.
+  return false;
+}
+
+void GDataOperationRegistry::NotifyStatusToObservers() {
+  ProgressStatusList list(GetProgressStatusList());
+  if (ShouldNotifyStatusNow(list))
+    FOR_EACH_OBSERVER(Observer, observer_list_, OnProgressUpdate(list));
+}
+
 }  // namespace gdata