Adaptive delay between successive component updates.

components/update_client/action.cc

 // Copyright 2015 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 "components/update_client/action.h"
 
 #include <algorithm>
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/update_client/action_update.h"
 #include "components/update_client/action_wait.h"
 #include "components/update_client/configurator.h"
@@ skipping 98 matching lines @@
 }
 
 void ActionImpl::UpdateCrx() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!update_context_->queue.empty());
 
   const std::string& id = update_context_->queue.front();
   CrxUpdateItem* item = FindUpdateItemById(id);
   DCHECK(item);
 
+  item->update_begin = base::TimeTicks::Now();
+
   std::unique_ptr<Action> update_action(
       CanTryDiffUpdate(item, update_context_->config)
           ? ActionUpdateDiff::Create()
           : ActionUpdateFull::Create());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&Action::Run, base::Unretained(update_action.get()),
                             update_context_, callback_));
 
   update_context_->current_action.reset(update_action.release());
 }
 
 void ActionImpl::UpdateCrxComplete(CrxUpdateItem* item) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(item);
+
   update_context_->ping_manager->SendPing(item);
 
   update_context_->queue.pop();
 
   if (update_context_->queue.empty()) {
     UpdateComplete(0);
   } else {
-    // TODO(sorin): the value of timing interval between CRX updates might have
-    // to be injected at the call site of update_client::UpdateClient::Update.
-    const int wait_sec = update_context_->config->UpdateDelay();
+    DCHECK(!item->update_begin.is_null());
+
+    // Assume that the cost of applying the update is proportional with how
+    // long it took to apply it. Then delay the next update by the same time
+    // interval or the value provided by the configurator, whichever is less.
+    const base::TimeDelta max_update_delay =
+        base::TimeDelta::FromSeconds(update_context_->config->UpdateDelay());
+    const base::TimeDelta update_cost(base::TimeTicks::Now() -
+                                      item->update_begin);
+    DCHECK(update_cost >= base::TimeDelta());
 
     std::unique_ptr<ActionWait> action_wait(
-        new ActionWait(base::TimeDelta::FromSeconds(wait_sec)));
+        new ActionWait(std::min(update_cost, max_update_delay)));
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&Action::Run, base::Unretained(action_wait.get()),
                               update_context_, callback_));
 
     update_context_->current_action.reset(action_wait.release());
   }
 }
 
 void ActionImpl::UpdateComplete(int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback_, error));
 }
 
 }  // namespace update_client