components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/translate/content/renderer/translate_helper.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 "components/translate/content/renderer/translate_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/content/renderer/renderer_cld_data_provider.h"
 #include "components/translate/content/renderer/renderer_cld_data_provider_factory.h"
 #include "components/translate/content/renderer/renderer_cld_utils.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
 #include "components/translate/core/common/translate_util.h"
 #include "components/translate/core/language_detection/language_detection_util.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
@@ skipping 476 matching lines @@
     // Notify the browser we are done.
     render_view()->Send(
         new ChromeViewHostMsg_PageTranslated(render_view()->GetRoutingID(),
                                              actual_source_lang,
                                              target_lang_,
                                              TranslateErrors::NONE));
     return;
   }
 
   // The translation is still pending, check again later.
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&TranslateHelper::CheckTranslateStatus,
-                 weak_method_factory_.GetWeakPtr(), page_seq_no),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&TranslateHelper::CheckTranslateStatus,
+                            weak_method_factory_.GetWeakPtr(), page_seq_no),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
 void TranslateHelper::TranslatePageImpl(int page_seq_no, int count) {
   DCHECK_LT(count, kMaxTranslateInitCheckAttempts);
   if (page_seq_no_ != page_seq_no || !render_view()->GetWebView())
     return;
 
   if (!IsTranslateLibReady()) {
     // The library is not ready, try again later, unless we have tried several
     // times unsucessfully already.
     if (++count >= kMaxTranslateInitCheckAttempts) {
       NotifyBrowserTranslationFailed(TranslateErrors::INITIALIZATION_ERROR);
       return;
     }
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&TranslateHelper::TranslatePageImpl,
-                   weak_method_factory_.GetWeakPtr(),
-                   page_seq_no, count),
+                   weak_method_factory_.GetWeakPtr(), page_seq_no, count),
         AdjustDelay(count * kTranslateInitCheckDelayMs));
     return;
   }
 
   // The library is loaded, and ready for translation now.
   // Check JavaScript performance counters for UMA reports.
   ReportTimeToBeReady(
       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.readyTime"));
   ReportTimeToLoad(
       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.loadTime"));
 
   if (!StartTranslation()) {
     NotifyBrowserTranslationFailed(TranslateErrors::TRANSLATION_ERROR);
     return;
   }
   // Check the status of the translation.
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&TranslateHelper::CheckTranslateStatus,
-                 weak_method_factory_.GetWeakPtr(), page_seq_no),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&TranslateHelper::CheckTranslateStatus,
+                            weak_method_factory_.GetWeakPtr(), page_seq_no),
       AdjustDelay(kTranslateStatusCheckDelayMs));
 }
 
 void TranslateHelper::NotifyBrowserTranslationFailed(
     TranslateErrors::Type error) {
   translation_pending_ = false;
   // Notify the browser there was an error.
   render_view()->Send(new ChromeViewHostMsg_PageTranslated(
       render_view()->GetRoutingID(), source_lang_, target_lang_, error));
 }
@@ skipping 48 matching lines @@
   cld_data_provider_->SendCldDataRequest();
 
   // ... and enqueue another delayed task to call again. This will start a
   // chain of polling that will last until the pointer stops being NULL,
   // which is the right thing to do.
   // NB: In the great majority of cases, the data file will be available and
   // the very first delayed task will be a no-op that terminates the chain.
   // It's only while downloading the file that this will chain for a
   // nontrivial amount of time.
   // Use a weak pointer to avoid keeping this helper object around forever.
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&TranslateHelper::SendCldDataRequest,
-                 weak_method_factory_.GetWeakPtr(),
-                 next_delay_millis,
-                 next_delay_millis * 2),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&TranslateHelper::SendCldDataRequest,
+                            weak_method_factory_.GetWeakPtr(),
+                            next_delay_millis, next_delay_millis * 2),
       base::TimeDelta::FromMilliseconds(delay_millis));
 }
 
 void TranslateHelper::OnCldDataAvailable() {
   if (deferred_page_capture_) {
     deferred_page_capture_ = false; // Don't do this a second time.
     PageCapturedImpl(deferred_page_seq_no_, deferred_contents_);
     deferred_page_seq_no_ = -1; // Clean up for sanity
     deferred_contents_.clear(); // Clean up for sanity
   }
@@ skipping 20 matching lines @@
   // this, everything should start being ON_TIME. This should never run more
   // than twice in a page load, under any conditions.
   // Also note that language detection is triggered off of a delay AFTER the
   // page load completed event has fired, making this very much off the critical
   // path.
   content::RenderThread::Get()->UpdateHistograms(
       content::kHistogramSynchronizerReservedSequenceNumber);
 }
 
 }  // namespace translate