Send UMA recording state to TranslateRanker.

components/translate/core/browser/translate_ranker_impl_unittest.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 <initializer_list>
 #include <memory>
 
 #include "base/feature_list.h"
@@ skipping 301 matching lines @@
   // If we don't have a model, returns true.
   EXPECT_TRUE(ranker->ShouldOfferTranslation(&translate_event));
   EXPECT_NE(0U, translate_event.ranker_request_timestamp_sec());
   EXPECT_EQ(0U, translate_event.ranker_version());
   EXPECT_EQ(metrics::TranslateEventProto::NOT_QUERIED,
             translate_event.ranker_response());
 }
 
 TEST_F(TranslateRankerImplTest, RecordAndFlushEvents) {
   std::unique_ptr<translate::TranslateRanker> ranker = GetRankerForTest(0.0f);
+  ranker->EnableLogging(true);
   std::vector<metrics::TranslateEventProto> flushed_events;
 
   GURL url0("https://www.google.com");
   GURL url1("https://www.gmail.com");
 
   // Check that flushing an empty cache will return an empty vector.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
   ranker->RecordTranslateEvent(0, url0, &translate_event1_);
@@ skipping 19 matching lines @@
 
   ASSERT_EQ(2U, GetTestUkmRecorder()->sources_count());
   EXPECT_EQ(
       url0.spec(),
       GetTestUkmRecorder()->GetSourceForUrl(url0.spec().c_str())->url().spec());
   EXPECT_EQ(
       url1.spec(),
       GetTestUkmRecorder()->GetSourceForUrl(url1.spec().c_str())->url().spec());
 }
 
-TEST_F(TranslateRankerImplTest, LoggingDisabledViaOverride) {
+TEST_F(TranslateRankerImplTest, EnableLogging) {
   std::unique_ptr<translate::TranslateRankerImpl> ranker =
       GetRankerForTest(0.0f);
   std::vector<metrics::TranslateEventProto> flushed_events;
 
+  // Logging is disabled by default. No events will be cached.
+  ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
+  ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
+
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 
+  // Once we enable logging, events will be cached.
+  ranker->EnableLogging(true);
   ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
   ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
-  ranker->RecordTranslateEvent(2, GURL(), &translate_event3_);
 
-  // Logging is enabled by default, so events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
-  EXPECT_EQ(3U, flushed_events.size());
+  EXPECT_EQ(2U, flushed_events.size());
+  flushed_events.clear();
 
-  // Override the feature setting to disable logging.
+  // Turning logging back off, caching is disabled once again.
   ranker->EnableLogging(false);
-
   ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
   ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
-  ranker->RecordTranslateEvent(2, GURL(), &translate_event3_);
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 }
 
+TEST_F(TranslateRankerImplTest, EnableLoggingClearsCache) {
+  std::unique_ptr<translate::TranslateRankerImpl> ranker =
+      GetRankerForTest(0.0f);
+  std::vector<metrics::TranslateEventProto> flushed_events;
+  // Logging is disabled by default. No events will be cached.
+  ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
+  // Making sure that cache is still empty once logging is turned on.
+  ranker->EnableLogging(true);
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(0U, flushed_events.size());
+
+  // These events will be cached.
+  ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
+  ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
+  // Cache will not be cleared if the logging state does not change.
+  ranker->EnableLogging(true);
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(2U, flushed_events.size());
+  flushed_events.clear();
+  // Cache is now empty after being flushed.
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(0U, flushed_events.size());
+
+  // Filling cache again.
+  ranker->EnableLogging(true);
+  ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
+  ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
+  // Switching logging off will clear the cache.
+  ranker->EnableLogging(false);
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(0U, flushed_events.size());
+
+  // Filling cache again.
+  ranker->EnableLogging(true);
+  ranker->RecordTranslateEvent(0, GURL(), &translate_event1_);
+  ranker->RecordTranslateEvent(1, GURL(), &translate_event2_);
+  // Switching logging off and on again will clear the cache.
+  ranker->EnableLogging(false);
+  ranker->EnableLogging(true);
+  ranker->FlushTranslateEvents(&flushed_events);
+  EXPECT_EQ(0U, flushed_events.size());
+}
+
 TEST_F(TranslateRankerImplTest, ShouldOverrideDecision_OverrideDisabled) {
   InitFeatures({}, {kTranslateRankerDecisionOverride});
   std::unique_ptr<translate::TranslateRankerImpl> ranker =
       GetRankerForTest(0.0f);
+  ranker->EnableLogging(true);
   const int kEventType = 12;
   metrics::TranslateEventProto translate_event = CreateDefaultTranslateEvent();
 
   EXPECT_FALSE(
       ranker->ShouldOverrideDecision(kEventType, GURL(), &translate_event));
 
   std::vector<metrics::TranslateEventProto> flushed_events;
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(1U, flushed_events.size());
   ASSERT_EQ(translate_event.source_language(),
             flushed_events[0].source_language());
   ASSERT_EQ(kEventType, flushed_events[0].event_type());
 }
 
 TEST_F(TranslateRankerImplTest, ShouldOverrideDecision_OverrideEnabled) {
   InitFeatures({kTranslateRankerDecisionOverride},
                {kTranslateRankerQuery, kTranslateRankerEnforcement});
   std::unique_ptr<translate::TranslateRankerImpl> ranker =
       GetRankerForTest(0.0f);
+  ranker->EnableLogging(true);
   metrics::TranslateEventProto translate_event = CreateDefaultTranslateEvent();
   // DecisionOverride is decoupled from querying and enforcement. Enabling
   // only DecisionOverride will not query the Ranker. Ranker returns its default
   // response.
   EXPECT_TRUE(
       GetRankerForTest(0.99f)->ShouldOfferTranslation(&translate_event));
   EXPECT_TRUE(ranker->ShouldOverrideDecision(1, GURL(), &translate_event));
   EXPECT_TRUE(ranker->ShouldOverrideDecision(2, GURL(), &translate_event));
 
   std::vector<metrics::TranslateEventProto> flushed_events;
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
   ASSERT_EQ(2, translate_event.decision_overrides_size());
   ASSERT_EQ(1, translate_event.decision_overrides(0));
   ASSERT_EQ(2, translate_event.decision_overrides(1));
   ASSERT_EQ(0, translate_event.event_type());
   EXPECT_EQ(metrics::TranslateEventProto::NOT_QUERIED,
             translate_event.ranker_response());
 }
 
 TEST_F(TranslateRankerImplTest,
        ShouldOverrideDecision_OverrideAndQueryEnabled) {
   InitFeatures({kTranslateRankerDecisionOverride, kTranslateRankerQuery},
                {kTranslateRankerEnforcement});
   // This test checks that translate events are properly logged when ranker is
   // queried and a decision is overridden.
   std::unique_ptr<translate::TranslateRankerImpl> ranker =
       GetRankerForTest(0.0f);
+  ranker->EnableLogging(true);
   metrics::TranslateEventProto translate_event = CreateDefaultTranslateEvent();
   // Ranker's decision is DONT_SHOW, but we are in query mode only, so Ranker
   // does not suppress the UI.
   EXPECT_TRUE(
       GetRankerForTest(0.99f)->ShouldOfferTranslation(&translate_event));
 
   int kOverrideType = 1;
   EXPECT_TRUE(
       ranker->ShouldOverrideDecision(kOverrideType, GURL(), &translate_event));
 
   int kEventType = 5;
   ranker->RecordTranslateEvent(kEventType, GURL(), &translate_event);
   std::vector<metrics::TranslateEventProto> flushed_events;
   ranker->FlushTranslateEvents(&flushed_events);
 
   EXPECT_EQ(1U, flushed_events.size());
   ASSERT_EQ(1, flushed_events[0].decision_overrides_size());
   ASSERT_EQ(kOverrideType, flushed_events[0].decision_overrides(0));
   ASSERT_EQ(kEventType, flushed_events[0].event_type());
   EXPECT_EQ(metrics::TranslateEventProto::DONT_SHOW,
             flushed_events[0].ranker_response());
 }