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 67 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 38 matching lines @@
 
 TranslateRankerImpl::TranslateRankerImpl(const base::FilePath& model_path,
                                          const GURL& model_url,
                                          ukm::UkmService* ukm_service)
     : ukm_service_(ukm_service),
       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 (is_query_enabled_ || is_enforcement_enabled_ ||
+      is_decision_override_enabled_) {
     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 24 matching lines @@
 
   DVLOG(3) << switches::kTranslateRankerModelURL << " = " << raw_url;
 
   return GURL(raw_url);
 }
 
 void TranslateRankerImpl::EnableLogging(bool value) {
   is_logging_enabled_ = value;
 }
 
-bool TranslateRankerImpl::IsLoggingEnabled() {
-  return is_logging_enabled_;
-}
-
-bool TranslateRankerImpl::IsQueryEnabled() {
-  return is_query_enabled_;
-}
-
-bool TranslateRankerImpl::IsEnforcementEnabled() {
-  return is_enforcement_enabled_;
-}
-
-int TranslateRankerImpl::GetModelVersion() const {
+uint32_t 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) {
+    const std::string& dst_lang,
+    metrics::TranslateEventProto* translate_event) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   // The ranker is a gate in the "show a translation prompt" flow. To retain
   // the pre-existing functionality, it defaults to returning true in the
   // absence of a model or if enforcement is disabled. As this is ranker is
   // subsumed into a more general assist ranker, this default will go away
   // (or become False).
   const bool kDefaultResponse = true;
 
+  translate_event->set_ranker_request_timestamp_sec(
+      (base::TimeTicks::Now() - base::TimeTicks()).InSeconds());
+  translate_event->set_ranker_version(GetModelVersion());
+
+  if (!is_query_enabled_ && !is_enforcement_enabled_ &&
+      !is_decision_override_enabled_) {
+    translate_event->set_ranker_response(
+        metrics::TranslateEventProto::NOT_QUERIED);
+    return kDefaultResponse;
+  }
+
   if (model_loader_)
     model_loader_->NotifyOfRankerActivity();
 
   // If we don't have a model, request one and return the default.
   if (model_ == nullptr) {
+    translate_event->set_ranker_response(
+        metrics::TranslateEventProto::NOT_QUERIED);
     return kDefaultResponse;
   }
 
   SCOPED_UMA_HISTOGRAM_TIMER("Translate.Ranker.Timer.ShouldOfferTranslation");
 
   // TODO(rogerm): Remove ScopedTracker below once crbug.com/646711 is closed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "646711 translate::TranslateRankerImpl::ShouldOfferTranslation"));
 
   TranslateRankerFeatures features(
       translate_prefs, src_lang, dst_lang,
       TranslateDownloadManager::GetInstance()->application_locale());
 
   double score = CalculateScore(features);
 
   DVLOG(2) << "TranslateRankerImpl::ShouldOfferTranslation: "
            << "Score = " << score << ", Features=[" << features << "]";
 
   bool result = (score >= kTranslationOfferThreshold);
 
   UMA_HISTOGRAM_BOOLEAN("Translate.Ranker.QueryResult", result);
 
+  translate_event->set_ranker_response(
+      result ? metrics::TranslateEventProto::SHOW
+             : metrics::TranslateEventProto::DONT_SHOW);
+
+  if (!is_enforcement_enabled_ && !is_decision_override_enabled_) {
+    return kDefaultResponse;
+  }
+
   return result;
 }
 
 double TranslateRankerImpl::CalculateScore(
     const TranslateRankerFeatures& features) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   SCOPED_UMA_HISTOGRAM_TIMER("Translate.Ranker.Timer.CalculateScore");
   DCHECK(model_ != nullptr);
   const TranslateRankerModel::LogisticRegressionModel& logit =
       model_->proto().translate().logistic_regression_model();
@@ skipping 46 matching lines @@
   builder->AddMetric("IgnoreCount", event.ignore_count());
   builder->AddMetric("RankerVersion", event.ranker_version());
   builder->AddMetric("RankerResponse", event.ranker_response());
   builder->AddMetric("EventType", event.event_type());
 }
 
 void TranslateRankerImpl::AddTranslateEvent(
     const metrics::TranslateEventProto& event,
     const GURL& url) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  if (IsLoggingEnabled()) {
+  if (is_logging_enabled_) {
     DVLOG(3) << "Adding translate ranker event.";
     if (url.is_valid()) {
       SendEventToUKM(event, url);
     }
     event_cache_.push_back(event);
   }
 }
 
 void TranslateRankerImpl::OnModelAvailable(std::unique_ptr<RankerModel> model) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   model_ = std::move(model);
 }
 
 bool TranslateRankerImpl::CheckModelLoaderForTesting() {
   return model_loader_ != nullptr;
 }
 
+void TranslateRankerImpl::RecordTranslateEvent(
+    int event_type,
+    const GURL& url,
+    metrics::TranslateEventProto* translate_event) {
+  DCHECK(metrics::TranslateEventProto::EventType_IsValid(event_type));
+  translate_event->set_event_type(
+      static_cast<metrics::TranslateEventProto::EventType>(event_type));
+  translate_event->set_event_timestamp_sec(
+      (base::TimeTicks::Now() - base::TimeTicks()).InSeconds());
+  AddTranslateEvent(*translate_event, url);
+}
+
+bool TranslateRankerImpl::ShouldOverrideDecision(
+    int event_type,
+    const GURL& url,
+    metrics::TranslateEventProto* translate_event) {
+  DCHECK(metrics::TranslateEventProto::EventType_IsValid(event_type));
+  if (is_decision_override_enabled_) {
+    translate_event->add_decision_overrides(
+        static_cast<metrics::TranslateEventProto::EventType>(event_type));
+    DVLOG(3) << "Overriding decision of type: " << event_type;
+    return true;
+  } else {
+    RecordTranslateEvent(event_type, url, translate_event);
+    return false;
+  }
+}
+
 }  // namespace translate
 
 std::ostream& operator<<(std::ostream& stream,
                          const translate::TranslateRankerFeatures& features) {
   features.WriteTo(stream);
   return stream;
 }