Send UMA recording state to TranslateRanker.

chrome/browser/translate/translate_ranker_metrics_provider.cc

 // Copyright 2017 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 "chrome/browser/translate/translate_ranker_metrics_provider.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/translate/translate_ranker_factory.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 #include "components/metrics/proto/translate_event.pb.h"
 #include "components/translate/core/browser/translate_ranker.h"
 
 namespace translate {
 
 void TranslateRankerMetricsProvider::ProvideGeneralMetrics(
     metrics::ChromeUserMetricsExtension* uma_proto) {
   std::vector<Profile*> loaded_profiles =
       g_browser_process->profile_manager()->GetLoadedProfiles();
   for (Profile* profile : loaded_profiles) {
     TranslateRanker* ranker =
         TranslateRankerFactory::GetForBrowserContext(profile);
     if (!ranker)
-      return;
+      continue;
 
     std::vector<metrics::TranslateEventProto> translate_events;
     ranker->FlushTranslateEvents(&translate_events);
 
     for (auto& event : translate_events) {
       uma_proto->add_translate_event()->Swap(&event);
     }
   }
 }
 
+void TranslateRankerMetricsProvider::SetLoggingState(bool logging_enabled) {
+  std::vector<Profile*> loaded_profiles =
+      g_browser_process->profile_manager()->GetLoadedProfiles();
+  for (Profile* profile : loaded_profiles) {

[Alexei Svitkine (slow), 2017/06/07 16:45:28]

So this will update the rankers for existing opened profiles. How about when a
new profile gets loaded?

I think you'd want to listen to profile creation events and update the ranking
state there.

Alternatively, it may be better to just have a global on/off switch - and then
you don't need to worry about profile lifecycles.

[hamelphi, 2017/06/08 20:27:58]

Who would own this switch? Ranker or UMA? I'd rather avoid using a global
variable in TranslateRanker if possible. If the metrics recording state
(https://cs.chromium.org/chromium/src/components/metrics_services_manager/metr...
maybe?) would be available globally, we could pass it as an argument to the
TranslateRanker constructor. However, my guess is that exposing this state
globally is probably not desirable.

How about we set the default to Disabled when we Initialize a Ranker object and
we only update the logging state on a profile once we receive OnRecordingEnabled
or ProvideGeneralMetrics. If I read the code correctly, OnRecordingEnabled is
called at startup, so we should not drop logging for profiles loaded at startup
(though I am not entirely sure if metrics is started after profiles are loaded).
We might lose logging on the first few TranslateEvents for profiles loaded
post-startup, but they should be enabled on the first call to
providegeneralmetrics. That sounds acceptable to me. What do you think?

+    TranslateRanker* ranker =
+        TranslateRankerFactory::GetForBrowserContext(profile);
+    if (ranker)
+      ranker->EnableLogging(logging_enabled);
+  }
+}
+
+void TranslateRankerMetricsProvider::OnRecordingEnabled() {
+  SetLoggingState(true);
+}
+
+void TranslateRankerMetricsProvider::OnRecordingDisabled() {
+  SetLoggingState(false);
+}
+
 }  // namespace translate