src/chrome/renderer/translate/translate_helper.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/translate/translate_helper.h"
   6
   7 #if defined(CLD2_DYNAMIC_MODE)
   8 #include <stdint.h>
   9 #endif
  10
  11 #include "base/bind.h"
  12 #include "base/compiler_specific.h"
  13 #if defined(CLD2_DYNAMIC_MODE)
  14 #include "base/files/memory_mapped_file.h"
  15 #endif
  16 #include "base/logging.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/strings/string16.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "chrome/renderer/isolated_world_ids.h"
  22 #include "components/translate/content/common/translate_messages.h"
  23 #include "components/translate/core/common/translate_constants.h"
  24 #include "components/translate/core/common/translate_metrics.h"
  25 #include "components/translate/core/common/translate_util.h"
  26 #include "components/translate/core/language_detection/language_detection_util.h"
  27 #include "content/public/renderer/render_view.h"
  28 #include "extensions/common/constants.h"
  29 #include "extensions/renderer/extension_groups.h"
  30 #include "ipc/ipc_platform_file.h"
  31 #if defined(CLD2_DYNAMIC_MODE)
  32 #include "content/public/common/url_constants.h"
  33 #include "third_party/cld_2/src/public/compact_lang_det.h"
  34 #endif
  35 #include "third_party/WebKit/public/web/WebDocument.h"
  36 #include "third_party/WebKit/public/web/WebElement.h"
  37 #include "third_party/WebKit/public/web/WebFrame.h"
  38 #include "third_party/WebKit/public/web/WebNode.h"
  39 #include "third_party/WebKit/public/web/WebNodeList.h"
  40 #include "third_party/WebKit/public/web/WebScriptSource.h"
  41 #include "third_party/WebKit/public/web/WebView.h"
  42 #include "third_party/WebKit/public/web/WebWidget.h"
  43 #include "url/gurl.h"
  44 #include "v8/include/v8.h"
  45
  46 using base::ASCIIToUTF16;
  47 using blink::WebDocument;
  48 using blink::WebElement;
  49 using blink::WebFrame;
  50 using blink::WebNode;
  51 using blink::WebNodeList;
  52 using blink::WebScriptSource;
  53 using blink::WebSecurityOrigin;
  54 using blink::WebString;
  55 using blink::WebVector;
  56 using blink::WebView;
  57
  58 namespace {
  59
  60 // The delay in milliseconds that we'll wait before checking to see if the
  61 // translate library injected in the page is ready.
  62 const int kTranslateInitCheckDelayMs = 150;
  63
  64 // The maximum number of times we'll check to see if the translate library
  65 // injected in the page is ready.
  66 const int kMaxTranslateInitCheckAttempts = 5;
  67
  68 // The delay we wait in milliseconds before checking whether the translation has
  69 // finished.
  70 const int kTranslateStatusCheckDelayMs = 400;
  71
  72 // Language name passed to the Translate element for it to detect the language.
  73 const char kAutoDetectionLanguage[] = "auto";
  74
  75 // Isolated world sets following content-security-policy.
  76 const char kContentSecurityPolicy[] = "script-src 'self' 'unsafe-eval'";
  77
  78 }  // namespace
  79
  80 #if defined(CLD2_DYNAMIC_MODE)
  81 // The mmap for the CLD2 data must be held forever once it is available in the
  82 // process. This is declared static in the translate_helper.h.
  83 base::LazyInstance<TranslateHelper::CLDMmapWrapper>::Leaky
  84   TranslateHelper::s_cld_mmap_ = LAZY_INSTANCE_INITIALIZER;
  85 #endif
  86
  87 ////////////////////////////////////////////////////////////////////////////////
  88 // TranslateHelper, public:
  89 //
  90 TranslateHelper::TranslateHelper(content::RenderView* render_view)
  91     : content::RenderViewObserver(render_view),
  92       page_id_(-1),
  93       translation_pending_(false),
  94       weak_method_factory_(this)
  95 #if defined(CLD2_DYNAMIC_MODE)
  96       ,cld2_data_file_polling_started_(false),
  97       cld2_data_file_polling_canceled_(false),
  98       deferred_page_capture_(false),
  99       deferred_page_id_(-1),
 100       deferred_contents_(ASCIIToUTF16(""))
 101 #endif
 102   {
 103 }
 104
 105 TranslateHelper::~TranslateHelper() {
 106   CancelPendingTranslation();
 107 #if defined(CLD2_DYNAMIC_MODE)
 108   CancelCLD2DataFilePolling();
 109 #endif
 110 }
 111
 112 void TranslateHelper::PrepareForUrl(const GURL& url) {
 113 #if defined(CLD2_DYNAMIC_MODE)
 114   deferred_page_capture_ = false;
 115   deferred_contents_.clear();
 116   if (cld2_data_file_polling_started_)
 117     return;
 118
 119   // TODO(andrewhayden): Refactor translate_manager.cc's IsTranslatableURL to
 120   // components/translate/core/common/translate_util.cc, and ignore any URL
 121   // that fails that check. This will require moving unit tests and rewiring
 122   // other function calls as well, so for now replicate the logic here.
 123   if (url.is_empty())
 124     return;
 125   if (url.SchemeIs(content::kChromeUIScheme))
 126     return;
 127   if (url.SchemeIs(content::kChromeDevToolsScheme))
 128     return;
 129   if (url.SchemeIs(url::kFtpScheme))
 130     return;
 131 #if defined(OS_CHROMEOS)
 132   if (url.SchemeIs(extensions::kExtensionScheme) &&
 133       url.DomainIs(file_manager::kFileManagerAppId))
 134     return;
 135 #endif
 136
 137   // Start polling for CLD data.
 138   cld2_data_file_polling_started_ = true;
 139   TranslateHelper::SendCLD2DataFileRequest(0, 1000);
 140 #endif
 141 }
 142
 143 #if defined(CLD2_DYNAMIC_MODE)
 144 void TranslateHelper::DeferPageCaptured(const int page_id,
 145                                         const base::string16& contents) {
 146   deferred_page_capture_ = true;
 147   deferred_page_id_ = page_id;
 148   deferred_contents_ = contents;
 149 }
 150 #endif
 151
 152 void TranslateHelper::PageCaptured(int page_id,
 153                                    const base::string16& contents) {
 154   // Get the document language as set by WebKit from the http-equiv
 155   // meta tag for "content-language".  This may or may not also
 156   // have a value derived from the actual Content-Language HTTP
 157   // header.  The two actually have different meanings (despite the
 158   // original intent of http-equiv to be an equivalent) with the former
 159   // being the language of the document and the latter being the
 160   // language of the intended audience (a distinction really only
 161   // relevant for things like langauge textbooks).  This distinction
 162   // shouldn't affect translation.
 163   WebFrame* main_frame = GetMainFrame();
 164   if (!main_frame || render_view()->GetPageId() != page_id)
 165     return;
 166
 167   // TODO(andrewhayden): UMA insertion point here: Track if data is available.
 168   // TODO(andrewhayden): Retry insertion point here, retry till data available.
 169 #if defined(CLD2_DYNAMIC_MODE)
 170   if (!CLD2::isDataLoaded()) {
 171     // We're in dynamic mode and CLD data isn't loaded. Retry when CLD data
 172     // is loaded, if ever.
 173     TranslateHelper::DeferPageCaptured(page_id, contents);
 174     return;
 175   }
 176 #endif
 177   page_id_ = page_id;
 178   WebDocument document = main_frame->document();
 179   std::string content_language = document.contentLanguage().utf8();
 180   WebElement html_element = document.documentElement();
 181   std::string html_lang;
 182   // |html_element| can be null element, e.g. in
 183   // BrowserTest.WindowOpenClose.
 184   if (!html_element.isNull())
 185     html_lang = html_element.getAttribute("lang").utf8();
 186   std::string cld_language;
 187   bool is_cld_reliable;
 188   std::string language = translate::DeterminePageLanguage(
 189       content_language, html_lang, contents, &cld_language, &is_cld_reliable);
 190
 191   if (language.empty())
 192     return;
 193
 194   language_determined_time_ = base::TimeTicks::Now();
 195
 196   GURL url(document.url());
 197   LanguageDetectionDetails details;
 198   details.time = base::Time::Now();
 199   details.url = url;
 200   details.content_language = content_language;
 201   details.cld_language = cld_language;
 202   details.is_cld_reliable = is_cld_reliable;
 203   details.html_root_language = html_lang;
 204   details.adopted_language = language;
 205
 206   // TODO(hajimehoshi): If this affects performance, it should be set only if
 207   // translate-internals tab exists.
 208   details.contents = contents;
 209
 210   Send(new ChromeViewHostMsg_TranslateLanguageDetermined(
 211       routing_id(),
 212       details,
 213       IsTranslationAllowed(&document) && !language.empty()));
 214 }
 215
 216 void TranslateHelper::CancelPendingTranslation() {
 217   weak_method_factory_.InvalidateWeakPtrs();
 218   translation_pending_ = false;
 219   source_lang_.clear();
 220   target_lang_.clear();
 221 #if defined(CLD2_DYNAMIC_MODE)
 222   CancelCLD2DataFilePolling();
 223 #endif
 224 }
 225
 226 ////////////////////////////////////////////////////////////////////////////////
 227 // TranslateHelper, protected:
 228 //
 229 bool TranslateHelper::IsTranslateLibAvailable() {
 230   return ExecuteScriptAndGetBoolResult(
 231       "typeof cr != 'undefined' && typeof cr.googleTranslate != 'undefined' && "
 232       "typeof cr.googleTranslate.translate == 'function'", false);
 233 }
 234
 235 bool TranslateHelper::IsTranslateLibReady() {
 236   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.libReady", false);
 237 }
 238
 239 bool TranslateHelper::HasTranslationFinished() {
 240   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.finished", true);
 241 }
 242
 243 bool TranslateHelper::HasTranslationFailed() {
 244   return ExecuteScriptAndGetBoolResult("cr.googleTranslate.error", true);
 245 }
 246
 247 bool TranslateHelper::StartTranslation() {
 248   std::string script = "cr.googleTranslate.translate('" +
 249                        source_lang_ +
 250                        "','" +
 251                        target_lang_ +
 252                        "')";
 253   return ExecuteScriptAndGetBoolResult(script, false);
 254 }
 255
 256 std::string TranslateHelper::GetOriginalPageLanguage() {
 257   return ExecuteScriptAndGetStringResult("cr.googleTranslate.sourceLang");
 258 }
 259
 260 base::TimeDelta TranslateHelper::AdjustDelay(int delayInMs) {
 261   // Just converts |delayInMs| without any modification in practical cases.
 262   // Tests will override this function to return modified value.
 263   return base::TimeDelta::FromMilliseconds(delayInMs);
 264 }
 265
 266 void TranslateHelper::ExecuteScript(const std::string& script) {
 267   WebFrame* main_frame = GetMainFrame();
 268   if (!main_frame)
 269     return;
 270
 271   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
 272   main_frame->executeScriptInIsolatedWorld(
 273       chrome::ISOLATED_WORLD_ID_TRANSLATE,
 274       &source,
 275       1,
 276       extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS);
 277 }
 278
 279 bool TranslateHelper::ExecuteScriptAndGetBoolResult(const std::string& script,
 280                                                     bool fallback) {
 281   WebFrame* main_frame = GetMainFrame();
 282   if (!main_frame)
 283     return fallback;
 284
 285   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 286   WebVector<v8::Local<v8::Value> > results;
 287   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
 288   main_frame->executeScriptInIsolatedWorld(
 289       chrome::ISOLATED_WORLD_ID_TRANSLATE,
 290       &source,
 291       1,
 292       extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
 293       &results);
 294   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsBoolean()) {
 295     NOTREACHED();
 296     return fallback;
 297   }
 298
 299   return results[0]->BooleanValue();
 300 }
 301
 302 std::string TranslateHelper::ExecuteScriptAndGetStringResult(
 303     const std::string& script) {
 304   WebFrame* main_frame = GetMainFrame();
 305   if (!main_frame)
 306     return std::string();
 307
 308   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 309   WebVector<v8::Local<v8::Value> > results;
 310   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
 311   main_frame->executeScriptInIsolatedWorld(
 312       chrome::ISOLATED_WORLD_ID_TRANSLATE,
 313       &source,
 314       1,
 315       extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
 316       &results);
 317   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsString()) {
 318     NOTREACHED();
 319     return std::string();
 320   }
 321
 322   v8::Local<v8::String> v8_str = results[0]->ToString();
 323   int length = v8_str->Utf8Length() + 1;
 324   scoped_ptr<char[]> str(new char[length]);
 325   v8_str->WriteUtf8(str.get(), length);
 326   return std::string(str.get());
 327 }
 328
 329 double TranslateHelper::ExecuteScriptAndGetDoubleResult(
 330     const std::string& script) {
 331   WebFrame* main_frame = GetMainFrame();
 332   if (!main_frame)
 333     return 0.0;
 334
 335   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 336   WebVector<v8::Local<v8::Value> > results;
 337   WebScriptSource source = WebScriptSource(ASCIIToUTF16(script));
 338   main_frame->executeScriptInIsolatedWorld(
 339       chrome::ISOLATED_WORLD_ID_TRANSLATE,
 340       &source,
 341       1,
 342       extensions::EXTENSION_GROUP_INTERNAL_TRANSLATE_SCRIPTS,
 343       &results);
 344   if (results.size() != 1 || results[0].IsEmpty() || !results[0]->IsNumber()) {
 345     NOTREACHED();
 346     return 0.0;
 347   }
 348
 349   return results[0]->NumberValue();
 350 }
 351
 352 ////////////////////////////////////////////////////////////////////////////////
 353 // TranslateHelper, private:
 354 //
 355
 356 // static
 357 bool TranslateHelper::IsTranslationAllowed(WebDocument* document) {
 358   WebElement head = document->head();
 359   if (head.isNull() || !head.hasChildNodes())
 360     return true;
 361
 362   const WebString meta(ASCIIToUTF16("meta"));
 363   const WebString name(ASCIIToUTF16("name"));
 364   const WebString google(ASCIIToUTF16("google"));
 365   const WebString value(ASCIIToUTF16("value"));
 366   const WebString content(ASCIIToUTF16("content"));
 367
 368   WebNodeList children = head.childNodes();
 369   for (size_t i = 0; i < children.length(); ++i) {
 370     WebNode node = children.item(i);
 371     if (!node.isElementNode())
 372       continue;
 373     WebElement element = node.to<WebElement>();
 374     // Check if a tag is <meta>.
 375     if (!element.hasTagName(meta))
 376       continue;
 377     // Check if the tag contains name="google".
 378     WebString attribute = element.getAttribute(name);
 379     if (attribute.isNull() || attribute != google)
 380       continue;
 381     // Check if the tag contains value="notranslate", or content="notranslate".
 382     attribute = element.getAttribute(value);
 383     if (attribute.isNull())
 384       attribute = element.getAttribute(content);
 385     if (attribute.isNull())
 386       continue;
 387     if (LowerCaseEqualsASCII(attribute, "notranslate"))
 388       return false;
 389   }
 390   return true;
 391 }
 392
 393 bool TranslateHelper::OnMessageReceived(const IPC::Message& message) {
 394   bool handled = true;
 395   IPC_BEGIN_MESSAGE_MAP(TranslateHelper, message)
 396     IPC_MESSAGE_HANDLER(ChromeViewMsg_TranslatePage, OnTranslatePage)
 397     IPC_MESSAGE_HANDLER(ChromeViewMsg_RevertTranslation, OnRevertTranslation)
 398 #if defined(CLD2_DYNAMIC_MODE)
 399     IPC_MESSAGE_HANDLER(ChromeViewMsg_CLDDataAvailable, OnCLDDataAvailable);
 400 #endif
 401     IPC_MESSAGE_UNHANDLED(handled = false)
 402   IPC_END_MESSAGE_MAP()
 403   return handled;
 404 }
 405
 406 void TranslateHelper::OnTranslatePage(int page_id,
 407                                       const std::string& translate_script,
 408                                       const std::string& source_lang,
 409                                       const std::string& target_lang) {
 410   WebFrame* main_frame = GetMainFrame();
 411   if (!main_frame ||
 412       page_id_ != page_id ||
 413       render_view()->GetPageId() != page_id)
 414     return;  // We navigated away, nothing to do.
 415
 416   // A similar translation is already under way, nothing to do.
 417   if (translation_pending_ && target_lang_ == target_lang)
 418     return;
 419
 420   // Any pending translation is now irrelevant.
 421   CancelPendingTranslation();
 422
 423   // Set our states.
 424   translation_pending_ = true;
 425
 426   // If the source language is undetermined, we'll let the translate element
 427   // detect it.
 428   source_lang_ = (source_lang != translate::kUnknownLanguageCode) ?
 429                   source_lang : kAutoDetectionLanguage;
 430   target_lang_ = target_lang;
 431
 432   translate::ReportUserActionDuration(language_determined_time_,
 433                                       base::TimeTicks::Now());
 434
 435   GURL url(main_frame->document().url());
 436   translate::ReportPageScheme(url.scheme());
 437
 438   // Set up v8 isolated world with proper content-security-policy and
 439   // security-origin.
 440   WebFrame* frame = GetMainFrame();
 441   if (frame) {
 442     frame->setIsolatedWorldContentSecurityPolicy(
 443         chrome::ISOLATED_WORLD_ID_TRANSLATE,
 444         WebString::fromUTF8(kContentSecurityPolicy));
 445
 446     GURL security_origin = translate::GetTranslateSecurityOrigin();
 447     frame->setIsolatedWorldSecurityOrigin(
 448         chrome::ISOLATED_WORLD_ID_TRANSLATE,
 449         WebSecurityOrigin::create(security_origin));
 450   }
 451
 452   if (!IsTranslateLibAvailable()) {
 453     // Evaluate the script to add the translation related method to the global
 454     // context of the page.
 455     ExecuteScript(translate_script);
 456     DCHECK(IsTranslateLibAvailable());
 457   }
 458
 459   TranslatePageImpl(0);
 460 }
 461
 462 void TranslateHelper::OnRevertTranslation(int page_id) {
 463   if (page_id_ != page_id || render_view()->GetPageId() != page_id)
 464     return;  // We navigated away, nothing to do.
 465
 466   if (!IsTranslateLibAvailable()) {
 467     NOTREACHED();
 468     return;
 469   }
 470
 471   CancelPendingTranslation();
 472
 473   ExecuteScript("cr.googleTranslate.revert()");
 474 }
 475
 476 void TranslateHelper::CheckTranslateStatus() {
 477   // If this is not the same page, the translation has been canceled.  If the
 478   // view is gone, the page is closing.
 479   if (page_id_ != render_view()->GetPageId() || !render_view()->GetWebView())
 480     return;
 481
 482   // First check if there was an error.
 483   if (HasTranslationFailed()) {
 484     // TODO(toyoshim): Check |errorCode| of translate.js and notify it here.
 485     NotifyBrowserTranslationFailed(TranslateErrors::TRANSLATION_ERROR);
 486     return;  // There was an error.
 487   }
 488
 489   if (HasTranslationFinished()) {
 490     std::string actual_source_lang;
 491     // Translation was successfull, if it was auto, retrieve the source
 492     // language the Translate Element detected.
 493     if (source_lang_ == kAutoDetectionLanguage) {
 494       actual_source_lang = GetOriginalPageLanguage();
 495       if (actual_source_lang.empty()) {
 496         NotifyBrowserTranslationFailed(TranslateErrors::UNKNOWN_LANGUAGE);
 497         return;
 498       } else if (actual_source_lang == target_lang_) {
 499         NotifyBrowserTranslationFailed(TranslateErrors::IDENTICAL_LANGUAGES);
 500         return;
 501       }
 502     } else {
 503       actual_source_lang = source_lang_;
 504     }
 505
 506     if (!translation_pending_) {
 507       NOTREACHED();
 508       return;
 509     }
 510
 511     translation_pending_ = false;
 512
 513     // Check JavaScript performance counters for UMA reports.
 514     translate::ReportTimeToTranslate(
 515         ExecuteScriptAndGetDoubleResult("cr.googleTranslate.translationTime"));
 516
 517     // Notify the browser we are done.
 518     render_view()->Send(new ChromeViewHostMsg_PageTranslated(
 519         render_view()->GetRoutingID(), render_view()->GetPageId(),
 520         actual_source_lang, target_lang_, TranslateErrors::NONE));
 521     return;
 522   }
 523
 524   // The translation is still pending, check again later.
 525   base::MessageLoop::current()->PostDelayedTask(
 526       FROM_HERE,
 527       base::Bind(&TranslateHelper::CheckTranslateStatus,
 528                  weak_method_factory_.GetWeakPtr()),
 529       AdjustDelay(kTranslateStatusCheckDelayMs));
 530 }
 531
 532 void TranslateHelper::TranslatePageImpl(int count) {
 533   DCHECK_LT(count, kMaxTranslateInitCheckAttempts);
 534   if (page_id_ != render_view()->GetPageId() || !render_view()->GetWebView())
 535     return;
 536
 537   if (!IsTranslateLibReady()) {
 538     // The library is not ready, try again later, unless we have tried several
 539     // times unsucessfully already.
 540     if (++count >= kMaxTranslateInitCheckAttempts) {
 541       NotifyBrowserTranslationFailed(TranslateErrors::INITIALIZATION_ERROR);
 542       return;
 543     }
 544     base::MessageLoop::current()->PostDelayedTask(
 545         FROM_HERE,
 546         base::Bind(&TranslateHelper::TranslatePageImpl,
 547                    weak_method_factory_.GetWeakPtr(),
 548                    count),
 549         AdjustDelay(count * kTranslateInitCheckDelayMs));
 550     return;
 551   }
 552
 553   // The library is loaded, and ready for translation now.
 554   // Check JavaScript performance counters for UMA reports.
 555   translate::ReportTimeToBeReady(
 556       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.readyTime"));
 557   translate::ReportTimeToLoad(
 558       ExecuteScriptAndGetDoubleResult("cr.googleTranslate.loadTime"));
 559
 560   if (!StartTranslation()) {
 561     NotifyBrowserTranslationFailed(TranslateErrors::TRANSLATION_ERROR);
 562     return;
 563   }
 564   // Check the status of the translation.
 565   base::MessageLoop::current()->PostDelayedTask(
 566       FROM_HERE,
 567       base::Bind(&TranslateHelper::CheckTranslateStatus,
 568                  weak_method_factory_.GetWeakPtr()),
 569       AdjustDelay(kTranslateStatusCheckDelayMs));
 570 }
 571
 572 void TranslateHelper::NotifyBrowserTranslationFailed(
 573     TranslateErrors::Type error) {
 574   translation_pending_ = false;
 575   // Notify the browser there was an error.
 576   render_view()->Send(new ChromeViewHostMsg_PageTranslated(
 577       render_view()->GetRoutingID(), page_id_, source_lang_,
 578       target_lang_, error));
 579 }
 580
 581 WebFrame* TranslateHelper::GetMainFrame() {
 582   WebView* web_view = render_view()->GetWebView();
 583
 584   // When the tab is going to be closed, the web_view can be NULL.
 585   if (!web_view)
 586     return NULL;
 587
 588   return web_view->mainFrame();
 589 }
 590
 591 #if defined(CLD2_DYNAMIC_MODE)
 592 void TranslateHelper::CancelCLD2DataFilePolling() {
 593   cld2_data_file_polling_canceled_ = true;
 594 }
 595
 596 void TranslateHelper::SendCLD2DataFileRequest(const int delay_millis,
 597                                               const int next_delay_millis) {
 598   // Terminate immediately if told to stop polling.
 599   if (cld2_data_file_polling_canceled_)
 600     return;
 601
 602   // Terminate immediately if data is already loaded.
 603   if (CLD2::isDataLoaded())
 604     return;
 605
 606   // Else, send the IPC message to the browser process requesting the data...
 607   Send(new ChromeViewHostMsg_NeedCLDData(routing_id()));
 608
 609   // ... and enqueue another delayed task to call again. This will start a
 610   // chain of polling that will last until the pointer stops being NULL,
 611   // which is the right thing to do.
 612   // NB: In the great majority of cases, the data file will be available and
 613   // the very first delayed task will be a no-op that terminates the chain.
 614   // It's only while downloading the file that this will chain for a
 615   // nontrivial amount of time.
 616   // Use a weak pointer to avoid keeping this helper object around forever.
 617   base::MessageLoop::current()->PostDelayedTask(
 618       FROM_HERE,
 619       base::Bind(&TranslateHelper::SendCLD2DataFileRequest,
 620                  weak_method_factory_.GetWeakPtr(),
 621                  next_delay_millis, next_delay_millis),
 622       base::TimeDelta::FromMilliseconds(delay_millis));
 623 }
 624
 625 void TranslateHelper::OnCLDDataAvailable(
 626     const IPC::PlatformFileForTransit ipc_file_handle,
 627     const uint64 data_offset,
 628     const uint64 data_length) {
 629   LoadCLDDData(IPC::PlatformFileForTransitToFile(ipc_file_handle), data_offset,
 630                data_length);
 631   if (deferred_page_capture_ && CLD2::isDataLoaded()) {
 632     deferred_page_capture_ = false; // Don't do this a second time.
 633     PageCaptured(deferred_page_id_, deferred_contents_);
 634     deferred_page_id_ = -1; // Clean up for sanity
 635     deferred_contents_.clear(); // Clean up for sanity
 636   }
 637 }
 638
 639 void TranslateHelper::LoadCLDDData(
 640     base::File file,
 641     const uint64 data_offset,
 642     const uint64 data_length) {
 643   // Terminate immediately if told to stop polling.
 644   if (cld2_data_file_polling_canceled_)
 645     return;
 646
 647   // Terminate immediately if data is already loaded.
 648   if (CLD2::isDataLoaded())
 649     return;
 650
 651   if (!file.IsValid()) {
 652     LOG(ERROR) << "Can't find the CLD data file.";
 653     return;
 654   }
 655
 656   // mmap the file
 657   s_cld_mmap_.Get().value = new base::MemoryMappedFile();
 658   bool initialized = s_cld_mmap_.Get().value->Initialize(file.Pass());
 659   if (!initialized) {
 660     LOG(ERROR) << "mmap initialization failed";
 661     delete s_cld_mmap_.Get().value;
 662     s_cld_mmap_.Get().value = NULL;
 663     return;
 664   }
 665
 666   // Sanity checks
 667   uint64 max_int32 = std::numeric_limits<int32>::max();
 668   if (data_length + data_offset > s_cld_mmap_.Get().value->length()
 669       || data_length > max_int32) { // max signed 32 bit integer
 670     LOG(ERROR) << "Illegal mmap config: data_offset="
 671         << data_offset << ", data_length=" << data_length
 672         << ", mmap->length()=" << s_cld_mmap_.Get().value->length();
 673     delete s_cld_mmap_.Get().value;
 674     s_cld_mmap_.Get().value = NULL;
 675     return;
 676   }
 677
 678   // Initialize the CLD subsystem... and it's all done!
 679   const uint8* data_ptr = s_cld_mmap_.Get().value->data() + data_offset;
 680   CLD2::loadDataFromRawAddress(data_ptr, data_length);
 681   DCHECK(CLD2::isDataLoaded()) << "Failed to load CLD data from mmap";
 682 }
 683 #endif