Updates language model on iOS.

components/translate/ios/browser/language_detection_controller.mm

 // Copyright 2014 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/ios/browser/language_detection_controller.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
   translate_enabled_.Init(prefs::kEnableTranslate, prefs);
   web_state->AddScriptCommandCallback(
       base::Bind(&LanguageDetectionController::OnTextCaptured,
                  base::Unretained(this)),
       kCommandPrefix);
 }
 
 LanguageDetectionController::~LanguageDetectionController() {
 }
 
+LanguageDetectionController::DetectionDetails::DetectionDetails()
+    : is_cld_reliable(false) {}
+
+LanguageDetectionController::DetectionDetails::DetectionDetails(
+    const DetectionDetails& other) = default;
+
+LanguageDetectionController::DetectionDetails::~DetectionDetails() = default;
+
 std::unique_ptr<LanguageDetectionController::CallbackList::Subscription>
 LanguageDetectionController::RegisterLanguageDetectionCallback(
     const Callback& callback) {
   return language_detection_callbacks_.Add(callback);
 }
 
 void LanguageDetectionController::StartLanguageDetection() {
   if (!translate_enabled_.GetValue())
     return;  // Translate disabled in preferences.
   DCHECK(web_state());
@@ skipping 43 matching lines @@
                    base::Bind(&LanguageDetectionController::OnTextRetrieved,
                               weak_method_factory_.GetWeakPtr(),
                               http_content_language, html_lang)];
   return true;
 }
 
 void LanguageDetectionController::OnTextRetrieved(
     const std::string& http_content_language,
     const std::string& html_lang,
     const base::string16& text_content) {
+  std::string cld_language;
+  bool is_cld_reliable;
   std::string language = translate::DeterminePageLanguage(
       http_content_language, html_lang,
       GetStringByClippingLastWord(text_content,
                                   language_detection::kMaxIndexChars),
-      nullptr /* cld_language */, nullptr /* is_cld_reliable */);
+      &cld_language, &is_cld_reliable);
   if (language.empty())
     return;  // No language detected.
 
   DetectionDetails details;
   details.content_language = http_content_language;
   details.html_root_language = html_lang;
   details.adopted_language = language;
+  details.cld_language = cld_language;
+  details.is_cld_reliable = is_cld_reliable;
   language_detection_callbacks_.Notify(details);
 }
 
 // web::WebStateObserver implementation:
 
 void LanguageDetectionController::PageLoaded(
     web::PageLoadCompletionStatus load_completion_status) {
   if (load_completion_status == web::PageLoadCompletionStatus::SUCCESS)
     StartLanguageDetection();
 }
 
 void LanguageDetectionController::DidFinishNavigation(
     web::NavigationContext* navigation_context) {
   if (navigation_context->IsSameDocument())
     StartLanguageDetection();
 }
 
 void LanguageDetectionController::WebStateDestroyed() {
   web_state()->RemoveScriptCommandCallback(kCommandPrefix);
 }
 
 }  // namespace translate