Allow TranslateRanker to override decisions taken by heuristics.

components/translate/core/browser/translate_ranker_impl.cc

 // Copyright 2016 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/core/browser/translate_ranker_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 64 matching lines @@
 
 const base::Feature kTranslateRankerQuery{"TranslateRankerQuery",
                                           base::FEATURE_DISABLED_BY_DEFAULT};
 
 const base::Feature kTranslateRankerEnforcement{
     "TranslateRankerEnforcement", base::FEATURE_DISABLED_BY_DEFAULT};
 
 const base::Feature kTranslateRankerLogging{"TranslateRankerLogging",
                                             base::FEATURE_ENABLED_BY_DEFAULT};
 
+const base::Feature kTranslateRankerDecisionOverride{
+    "TranslateRankerDecisionOverride", base::FEATURE_DISABLED_BY_DEFAULT};
+
 TranslateRankerFeatures::TranslateRankerFeatures() {}
 
 TranslateRankerFeatures::TranslateRankerFeatures(int accepted,
                                                  int denied,
                                                  int ignored,
                                                  const std::string& src,
                                                  const std::string& dst,
                                                  const std::string& cntry,
                                                  const std::string& locale)
     : accepted_count(accepted),
@@ skipping 36 matching lines @@
          << "ignore_ratio=" << ignored_ratio;
 }
 
 TranslateRankerImpl::TranslateRankerImpl(const base::FilePath& model_path,
                                          const GURL& model_url)
     : is_logging_enabled_(
           base::FeatureList::IsEnabled(kTranslateRankerLogging)),
       is_query_enabled_(base::FeatureList::IsEnabled(kTranslateRankerQuery)),
       is_enforcement_enabled_(
           base::FeatureList::IsEnabled(kTranslateRankerEnforcement)),
+      is_decision_override_enabled_(base::FeatureList::IsEnabled(
+          translate::kTranslateRankerDecisionOverride)),
       weak_ptr_factory_(this) {
-  if (IsQueryEnabled() || IsEnforcementEnabled()) {
+  if (IsQueryEnabled() || IsEnforcementEnabled() ||
+      IsDecisionOverrideEnabled()) {
     model_loader_ = base::MakeUnique<RankerModelLoader>(
         base::Bind(&ValidateModel),
         base::Bind(&TranslateRankerImpl::OnModelAvailable,
                    weak_ptr_factory_.GetWeakPtr()),
         model_path, model_url, kUmaPrefix);
     model_loader_->Start();
   }
 }
 
 TranslateRankerImpl::~TranslateRankerImpl() {}
@@ skipping 36 matching lines @@
 }
 
 bool TranslateRankerImpl::IsQueryEnabled() {
   return is_query_enabled_;
 }
 
 bool TranslateRankerImpl::IsEnforcementEnabled() {
   return is_enforcement_enabled_;
 }
 
+bool TranslateRankerImpl::IsDecisionOverrideEnabled() {
+  return is_decision_override_enabled_;
+}
+
 int TranslateRankerImpl::GetModelVersion() const {
   return model_ ? model_->proto().translate().version() : 0;
 }
 
 bool TranslateRankerImpl::ShouldOfferTranslation(
     const TranslatePrefs& translate_prefs,
     const std::string& src_lang,
     const std::string& dst_lang) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   // The ranker is a gate in the "show a translation prompt" flow. To retain
@@ skipping 83 matching lines @@
   return model_loader_ != nullptr;
 }
 
 }  // namespace translate
 
 std::ostream& operator<<(std::ostream& stream,
                          const translate::TranslateRankerFeatures& features) {
   features.WriteTo(stream);
   return stream;
 }