Replace the RepeatingTimer in ImageDecoder with a DelayTimer.

chrome/browser/image_decoder.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/image_decoder.h"
 
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_utility_messages.h"
@@ skipping 10 matching lines @@
 // static, Leaky to allow access from any thread.
 base::LazyInstance<ImageDecoder>::Leaky g_decoder = LAZY_INSTANCE_INITIALIZER;
 
 // How long to wait after the last request has been received before ending
 // batch mode.
 const int kBatchModeTimeoutSeconds = 5;
 
 }  // namespace
 
 ImageDecoder::ImageDecoder()
-    : image_request_id_counter_(0), last_request_(base::TimeTicks::Now()) {
+    : image_request_id_counter_(0) {
   // A single ImageDecoder instance should live for the life of the program.
   // Explicitly add a reference so the object isn't deleted.
   AddRef();
 }
 
 ImageDecoder::~ImageDecoder() {
 }
 
 ImageDecoder::ImageRequest::ImageRequest()
     : task_runner_(base::ThreadTaskRunnerHandle::Get()) {
@@ skipping 74 matching lines @@
     // Utility process failed to start; notify delegate and return.
     // Without this check, we were seeing crashes on startup. Further
     // investigation is needed to determine why the utility process
     // is failing to start. See crbug.com/472272
     image_request->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ImageDecoder::RunOnDecodeImageFailed, this, request_id));
     return;
   }
 
-  last_request_ = base::TimeTicks::Now();
+  if (!batch_mode_timer_) {
+    // Created here so it will call StopBatchMode() on the right thread.
+    batch_mode_timer_.reset(new base::DelayTimer<ImageDecoder>(
+        FROM_HERE,
+        base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds),
+        this,
+        &ImageDecoder::StopBatchMode));
+  }
+  batch_mode_timer_->Reset();
 
   switch (image_codec) {
     case ROBUST_JPEG_CODEC:
       utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
           image_data, request_id));
       break;
     case DEFAULT_CODEC:
       utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
           image_data, shrink_to_fit, request_id));
       break;
@@ skipping 16 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   utility_process_host_ =
       UtilityProcessHost::Create(this, base::MessageLoopProxy::current().get())
           ->AsWeakPtr();
   utility_process_host_->SetName(l10n_util::GetStringUTF16(
       IDS_UTILITY_PROCESS_IMAGE_DECODER_NAME));
   if (!utility_process_host_->StartBatchMode()) {
      utility_process_host_.reset();
      return;
   }
-  batch_mode_timer_.Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds),
-      this, &ImageDecoder::StopBatchMode);
 }
 
 void ImageDecoder::StopBatchMode() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if ((base::TimeTicks::Now() - last_request_)
-      < base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds)) {
-    return;
-  }
-
   if (utility_process_host_) {
     utility_process_host_->EndBatchMode();
     utility_process_host_.reset();
   }
-  batch_mode_timer_.Stop();
 }
 
 bool ImageDecoder::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ImageDecoder, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Succeeded,
                         OnDecodeImageSucceeded)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Failed,
                         OnDecodeImageFailed)
@@ skipping 56 matching lines @@
     auto it = image_request_id_map_.find(request_id);
     if (it == image_request_id_map_.end())
       return;
     image_request = it->second;
     image_request_id_map_.erase(it);
   }
 
   DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread());
   image_request->OnDecodeImageFailed();
 }