Clean up std::string usage in translate_language_list and translate_browser_metrics

This CL cleans up std::string usage in translate_language_list.cc and
translate_browser_metrics.cc, expanding to callers in a few places. This
CL also includes some miscellaneous cleanup to these files, such as
removing the test-only method
translate::TranslateBrowserMetrics::GetMetricsName() and instead inlines
the string literals in the tests themselves.

This CL changes no functionality, and is clean up only.

Bug: 1109032
Change-Id: Icc18b29b7f79ec9e57b491548d1f05e032923ee8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2332363Reviewed-by: Megan Jablonski <megjablon@chromium.org>
Commit-Queue: Scott Little <sclittle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795603}

chrome/browser/translate/translate_manager_browsertest.cc

@@ -218,6 +218,9 @@ static const char kTestScriptLoadError[] =
     "})();"
     "cr.googleTranslate.onTranslateElementLoad();";
 
+static const char kTranslateHrefHintStatusHistogram[] =
+    "Translate.HrefHint.Status";
+
 }  // namespace
 
 class TranslateManagerBrowserTest : public InProcessBrowserTest {
@@ -526,12 +529,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, HrefTranslateSuccess) {
                    browser()->profile())
                    ->IsAcceptLanguage("ja"));
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -581,10 +580,7 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
 
   EXPECT_EQ("", chrome_translate_client->GetLanguageState().AutoTranslateTo());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 0);
+  histograms.ExpectTotalCount(kTranslateHrefHintStatusHistogram, 0);
 }
 
 // Test that hrefTranslate with an unsupported language doesn't trigger.
@@ -633,12 +629,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, HrefTranslateUnsupported) {
 
   EXPECT_EQ("", chrome_translate_client->GetLanguageState().AutoTranslateTo());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kNotAutoTranslated),
       1);
@@ -691,12 +683,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, HrefTranslateConflict) {
   EXPECT_EQ("en",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -751,12 +739,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest, HrefTranslateNoHrefLang) {
   EXPECT_EQ("en",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -815,12 +799,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerBrowserTest,
   EXPECT_EQ("zh-CN",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(TranslateBrowserMetrics::HrefTranslateStatus::
                            kAutoTranslatedDifferentTargetLanguage),
       1);
@@ -1384,12 +1364,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
                    browser()->profile())
                    ->IsAcceptLanguage("ja"));
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -1431,10 +1407,7 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
 
   EXPECT_EQ("", chrome_translate_client->GetLanguageState().AutoTranslateTo());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 0);
+  histograms.ExpectTotalCount(kTranslateHrefHintStatusHistogram, 0);
 }
 
 // Test that hrefTranslate with an unsupported language doesn't trigger.
@@ -1476,12 +1449,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
 
   EXPECT_EQ("", chrome_translate_client->GetLanguageState().AutoTranslateTo());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kNotAutoTranslated),
       1);
@@ -1527,12 +1496,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
   EXPECT_EQ("en",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -1578,12 +1543,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
   EXPECT_EQ("en",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(
           TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated),
       1);
@@ -1632,12 +1593,8 @@ IN_PROC_BROWSER_TEST_F(TranslateManagerWithSubFrameSupportBrowserTest,
   EXPECT_EQ("zh-CN",
             chrome_translate_client->GetLanguageState().current_language());
 
-  const char* translate_href_hint_status_name =
-      TranslateBrowserMetrics::GetMetricsName(
-          TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS);
-  histograms.ExpectTotalCount(translate_href_hint_status_name, 1);
-  histograms.ExpectBucketCount(
-      translate_href_hint_status_name,
+  histograms.ExpectUniqueSample(
+      kTranslateHrefHintStatusHistogram,
       static_cast<int>(TranslateBrowserMetrics::HrefTranslateStatus::
                            kAutoTranslatedDifferentTargetLanguage),
       1);

components/language_usage_metrics/language_usage_metrics.cc

@@ -4,56 +4,58 @@
 
 #include "components/language_usage_metrics/language_usage_metrics.h"
 
-#include <algorithm>
+#include <stddef.h>
 
 #include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_tokenizer.h"
-#include "base/strings/string_util.h"
-
-namespace {
-void RecordAcceptLanguage(int language_code) {
-  base::UmaHistogramSparse("LanguageUsage.AcceptLanguage", language_code);
-}
-void RecordLanguageCount(int language_count) {
-  UMA_HISTOGRAM_COUNTS_100("LanguageUsage.AcceptLanguage.Count",
-                           language_count);
-}
-}  // namespace
 
 namespace language_usage_metrics {
 
 // static
 void LanguageUsageMetrics::RecordAcceptLanguages(
-    const std::string& accept_languages) {
+    base::StringPiece accept_languages) {
   std::set<int> languages;
   ParseAcceptLanguages(accept_languages, &languages);
-  RecordLanguageCount(languages.size());
-  std::for_each(languages.begin(), languages.end(), RecordAcceptLanguage);
+
+  UMA_HISTOGRAM_COUNTS_100("LanguageUsage.AcceptLanguage.Count",
+                           languages.size());
+  for (int language_code : languages) {
+    base::UmaHistogramSparse("LanguageUsage.AcceptLanguage", language_code);
+  }
 }
 
 // static
 void LanguageUsageMetrics::RecordApplicationLanguage(
-    const std::string& application_locale) {
+    base::StringPiece application_locale) {
   const int language_code = ToLanguageCode(application_locale);
-  if (language_code != 0)
+  if (language_code != 0) {
     base::UmaHistogramSparse("LanguageUsage.ApplicationLanguage",
                              language_code);
+  }
 }
 
 // static
-int LanguageUsageMetrics::ToLanguageCode(const std::string& locale) {
-  base::StringTokenizer parts(locale, "-_");
-  if (!parts.GetNext())
-    return 0;
-
-  std::string language_part = base::ToLowerASCII(parts.token());
+int LanguageUsageMetrics::ToLanguageCode(base::StringPiece locale) {
+  base::StringPiece language_part =
+      locale.substr(0U, locale.find_first_of("-_"));
 
   int language_code = 0;
-  for (std::string::iterator it = language_part.begin();
-       it != language_part.end(); ++it) {
-    char ch = *it;
-    if (ch < 'a' || 'z' < ch)
+  for (size_t i = 0U; i < language_part.size(); ++i) {
+    // It's undefined behavior in C++ to left-shift a signed int past its sign
+    // bit, so only shift until the int's sign bit is reached. Note that it's
+    // safe to shift up to sizeof(int) times because each character is only
+    // added if it's between 'a' and 'z', which all have a 0 in their 7th bit.
+    // For example, for 4-byte ints, "zzzz" would be converted to 0x7A7A7A7A,
+    // which doesn't quite reach the sign bit, making it safe to insert up to 4
+    // characters.
+    if (i == sizeof(language_code))
+      return 0;
+
+    char ch = language_part[i];
+    if ('A' <= ch && ch <= 'Z')
+      ch += ('a' - 'A');
+    else if (ch < 'a' || 'z' < ch)
       return 0;
 
     language_code <<= 8;
@@ -65,12 +67,14 @@ int LanguageUsageMetrics::ToLanguageCode(const std::string& locale) {
 
 // static
 void LanguageUsageMetrics::ParseAcceptLanguages(
-    const std::string& accept_languages,
+    base::StringPiece accept_languages,
     std::set<int>* languages) {
   languages->clear();
-  base::StringTokenizer locales(accept_languages, ",");
+  base::CStringTokenizer locales(
+      accept_languages.data(),
+      accept_languages.data() + accept_languages.size(), ",");
   while (locales.GetNext()) {
-    const int language_code = ToLanguageCode(locales.token());
+    const int language_code = ToLanguageCode(locales.token_piece());
     if (language_code != 0)
       languages->insert(language_code);
   }

components/language_usage_metrics/language_usage_metrics.h

@@ -6,10 +6,10 @@
 #define COMPONENTS_LANGUAGE_USAGE_METRICS_LANGUAGE_USAGE_METRICS_H_
 
 #include <set>
-#include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/strings/string_piece.h"
 
 namespace language_usage_metrics {
 
@@ -21,28 +21,29 @@ class LanguageUsageMetrics {
   // xx-YY, or xx_YY format where xx is iso-639 language code and YY is iso-3166
   // country code. Country code is ignored. That is, xx and XX-YY are considered
   // identical and recorded once.
-  static void RecordAcceptLanguages(const std::string& accept_languages);
+  static void RecordAcceptLanguages(base::StringPiece accept_languages);
 
   // Records the application language as a UMA histogram. |application_locale|
   // is a case-insensitive locale string of either xx, xx-YY, or xx_YY format.
   // Only the language part (xx in the example) is considered.
-  static void RecordApplicationLanguage(const std::string& application_locale);
+  static void RecordApplicationLanguage(base::StringPiece application_locale);
 
   // Parses |locale| and returns the language code. Returns 0 in case of errors.
   // The language code is calculated from two alphabets. For example, if
   // |locale| is 'en' which represents 'English', the codes of 'e' and 'n' are
   // 101 and 110 respectively, and the language code will be 101 * 256 + 100 =
   // 25966.
-  // |locale| should consist of only lower-case letters. This function doesn't
-  // check whether |locale| is valid locale or not strictly.
-  static int ToLanguageCode(const std::string &locale);
+  // |locale| is case-insensitive, such that "EN" will return the same language
+  // code as "en". This function doesn't check whether |locale| is valid locale
+  // or not.
+  static int ToLanguageCode(base::StringPiece locale);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(LanguageUsageMetrics);
 
   // Parses |accept_languages| and returns a set of language codes in
   // |languages|.
-  static void ParseAcceptLanguages(const std::string& accept_languages,
+  static void ParseAcceptLanguages(base::StringPiece accept_languages,
                                    std::set<int>* languages);
 
   FRIEND_TEST_ALL_PREFIXES(LanguageUsageMetricsTest, ParseAcceptLanguages);

components/translate/core/browser/translate_browser_metrics.cc

@@ -4,15 +4,9 @@
 
 #include "components/translate/core/browser/translate_browser_metrics.h"
 
-#include <stddef.h>
-
-#include <string>
-
 #include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/metrics_hashes.h"
-#include "base/notreached.h"
-#include "base/stl_util.h"
 #include "components/language_usage_metrics/language_usage_metrics.h"
 
 namespace translate {
@@ -37,37 +31,6 @@ const char kTranslateTargetLanguage[] = "Translate.TargetLanguage";
 const char kTranslateHrefHintStatus[] = "Translate.HrefHint.Status";
 const char kTranslateTargetLanguageOrigin[] = "Translate.TargetLanguage.Origin";
 
-struct MetricsEntry {
-  TranslateBrowserMetrics::MetricsNameIndex index;
-  const char* const name;
-};
-
-// This entry table should be updated when new UMA items are added. This is only
-// used by GetMetricsName for testing.
-const MetricsEntry kMetricsEntries[] = {
-    {TranslateBrowserMetrics::UMA_INITIATION_STATUS,
-     kTranslateInitiationStatus},
-    {TranslateBrowserMetrics::UMA_LANGUAGE_DETECTION_ERROR,
-     kTranslateReportLanguageDetectionError},
-    {TranslateBrowserMetrics::UMA_LOCALES_ON_DISABLED_BY_PREFS,
-     kTranslateLocalesOnDisabledByPrefs},
-    {TranslateBrowserMetrics::UMA_UNDISPLAYABLE_LANGUAGE,
-     kTranslateUndisplayableLanguage},
-    {TranslateBrowserMetrics::UMA_UNSUPPORTED_LANGUAGE_AT_INITIATION,
-     kTranslateUnsupportedLanguageAtInitiation},
-    {TranslateBrowserMetrics::UMA_TRANSLATE_SOURCE_LANGUAGE,
-     kTranslateSourceLanguage},
-    {TranslateBrowserMetrics::UMA_TRANSLATE_TARGET_LANGUAGE,
-     kTranslateTargetLanguage},
-    {TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS,
-     kTranslateHrefHintStatus},
-    {TranslateBrowserMetrics::UMA_TRANSLATE_TARGET_LANGUAGE_ORIGIN,
-     kTranslateTargetLanguageOrigin},
-};
-
-static_assert(base::size(kMetricsEntries) == TranslateBrowserMetrics::UMA_MAX,
-              "kMetricsEntries should have UMA_MAX elements");
-
 }  // namespace
 
 namespace TranslateBrowserMetrics {
@@ -86,31 +49,31 @@ void ReportLanguageDetectionContentLength(size_t length) {
                                  length);
 }
 
-void ReportLocalesOnDisabledByPrefs(const std::string& locale) {
+void ReportLocalesOnDisabledByPrefs(base::StringPiece locale) {
   base::UmaHistogramSparse(
       kTranslateLocalesOnDisabledByPrefs,
       language_usage_metrics::LanguageUsageMetrics::ToLanguageCode(locale));
 }
 
-void ReportUndisplayableLanguage(const std::string& language) {
+void ReportUndisplayableLanguage(base::StringPiece language) {
   int language_code =
       language_usage_metrics::LanguageUsageMetrics::ToLanguageCode(language);
   base::UmaHistogramSparse(kTranslateUndisplayableLanguage, language_code);
 }
 
-void ReportUnsupportedLanguageAtInitiation(const std::string& language) {
+void ReportUnsupportedLanguageAtInitiation(base::StringPiece language) {
   int language_code =
       language_usage_metrics::LanguageUsageMetrics::ToLanguageCode(language);
   base::UmaHistogramSparse(kTranslateUnsupportedLanguageAtInitiation,
                            language_code);
 }
 
-void ReportTranslateSourceLanguage(const std::string& language) {
+void ReportTranslateSourceLanguage(base::StringPiece language) {
   base::UmaHistogramSparse(kTranslateSourceLanguage,
                            base::HashMetricName(language));
 }
 
-void ReportTranslateTargetLanguage(const std::string& language) {
+void ReportTranslateTargetLanguage(base::StringPiece language) {
   base::UmaHistogramSparse(kTranslateTargetLanguage,
                            base::HashMetricName(language));
 }
@@ -123,15 +86,6 @@ void ReportTranslateTargetLanguageOrigin(TargetLanguageOrigin origin) {
   base::UmaHistogramEnumeration(kTranslateTargetLanguageOrigin, origin);
 }
 
-const char* GetMetricsName(MetricsNameIndex index) {
-  for (size_t i = 0; i < base::size(kMetricsEntries); ++i) {
-    if (kMetricsEntries[i].index == index)
-      return kMetricsEntries[i].name;
-  }
-  NOTREACHED();
-  return nullptr;
-}
-
 }  // namespace TranslateBrowserMetrics
 
 }  // namespace translate

components/translate/core/browser/translate_browser_metrics.h

@@ -5,27 +5,14 @@
 #ifndef COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_BROWSER_METRICS_H_
 #define COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_BROWSER_METRICS_H_
 
-#include <string>
+#include <stddef.h>
+
+#include "base/strings/string_piece.h"
 
 namespace translate {
 
 namespace TranslateBrowserMetrics {
 
-// An indexing type to query each UMA entry name via GetMetricsName() function.
-// Note: |kMetricsEntries| should be updated when a new entry is added here.
-enum MetricsNameIndex {
-  UMA_INITIATION_STATUS,
-  UMA_LANGUAGE_DETECTION_ERROR,
-  UMA_LOCALES_ON_DISABLED_BY_PREFS,
-  UMA_UNDISPLAYABLE_LANGUAGE,
-  UMA_UNSUPPORTED_LANGUAGE_AT_INITIATION,
-  UMA_TRANSLATE_SOURCE_LANGUAGE,
-  UMA_TRANSLATE_TARGET_LANGUAGE,
-  UMA_TRANSLATE_HREF_HINT_STATUS,
-  UMA_TRANSLATE_TARGET_LANGUAGE_ORIGIN,
-  UMA_MAX,
-};
-
 // When Chrome Translate is ready to translate a page, one of following reasons
 // decides the next browser action.
 // Note: Don't insert items. It will change the reporting UMA value and break
@@ -90,23 +77,23 @@ void ReportLanguageDetectionError();
 // Called when language detection details are complete.
 void ReportLanguageDetectionContentLength(size_t length);
 
-void ReportLocalesOnDisabledByPrefs(const std::string& locale);
+void ReportLocalesOnDisabledByPrefs(base::StringPiece locale);
 
 // Called when Chrome Translate server sends the language list which includes
 // a undisplayable language in the user's locale.
-void ReportUndisplayableLanguage(const std::string& language);
+void ReportUndisplayableLanguage(base::StringPiece language);
 
-void ReportUnsupportedLanguageAtInitiation(const std::string& language);
+void ReportUnsupportedLanguageAtInitiation(base::StringPiece language);
 
 // Called when a request is sent to the translate server to report the source
 // language of the translated page. Buckets are labelled with CLD3LanguageCode
 // values.
-void ReportTranslateSourceLanguage(const std::string& language);
+void ReportTranslateSourceLanguage(base::StringPiece language);
 
 // Called when a request is sent to the translate server to report the target
 // language for the translated page. Buckets are labelled with CLD3LanguageCode
 // values.
-void ReportTranslateTargetLanguage(const std::string& language);
+void ReportTranslateTargetLanguage(base::StringPiece language);
 
 // Called when Chrome Translate is initiated, the navigation is from Google, and
 // a href translate target is present.
@@ -115,9 +102,6 @@ void ReportTranslateHrefHintStatus(HrefTranslateStatus status);
 // Called when Chrome Translate target language is determined.
 void ReportTranslateTargetLanguageOrigin(TargetLanguageOrigin origin);
 
-// Provides UMA entry names for unit tests.
-const char* GetMetricsName(MetricsNameIndex index);
-
 }  // namespace TranslateBrowserMetrics
 
 }  // namespace translate

components/translate/core/browser/translate_browser_metrics_unittest.cc

@@ -189,8 +189,7 @@ class MetricsRecorder {
 }  // namespace
 
 TEST(TranslateBrowserMetricsTest, ReportInitiationStatus) {
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_INITIATION_STATUS));
+  MetricsRecorder recorder("Translate.InitiationStatus.v2");
 
   recorder.CheckInitiationStatus(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
   translate::TranslateBrowserMetrics::ReportInitiationStatus(
@@ -246,8 +245,7 @@ TEST(TranslateBrowserMetricsTest, ReportInitiationStatus) {
 }
 
 TEST(TranslateBrowserMetricsTest, ReportLanguageDetectionError) {
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_LANGUAGE_DETECTION_ERROR));
+  MetricsRecorder recorder("Translate.ReportLanguageDetectionError");
   EXPECT_EQ(0, recorder.GetTotalCount());
   translate::TranslateBrowserMetrics::ReportLanguageDetectionError();
   EXPECT_EQ(1, recorder.GetTotalCount());
@@ -256,8 +254,7 @@ TEST(TranslateBrowserMetricsTest, ReportLanguageDetectionError) {
 TEST(TranslateBrowserMetricsTest, ReportedLocalesOnDisabledByPrefs) {
   const int ENGLISH = 25966;
 
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_LOCALES_ON_DISABLED_BY_PREFS));
+  MetricsRecorder recorder("Translate.LocalesOnDisabledByPrefs");
   EXPECT_EQ(0, recorder.GetTotalCount());
   translate::TranslateBrowserMetrics::ReportLocalesOnDisabledByPrefs("en");
   EXPECT_EQ(1, recorder.GetCount(ENGLISH));
@@ -266,8 +263,7 @@ TEST(TranslateBrowserMetricsTest, ReportedLocalesOnDisabledByPrefs) {
 TEST(TranslateBrowserMetricsTest, ReportedUndisplayableLanguage) {
   const int ENGLISH = 25966;
 
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_UNDISPLAYABLE_LANGUAGE));
+  MetricsRecorder recorder("Translate.UndisplayableLanguage");
   EXPECT_EQ(0, recorder.GetTotalCount());
   translate::TranslateBrowserMetrics::ReportUndisplayableLanguage("en");
   EXPECT_EQ(1, recorder.GetCount(ENGLISH));
@@ -276,9 +272,7 @@ TEST(TranslateBrowserMetricsTest, ReportedUndisplayableLanguage) {
 TEST(TranslateBrowserMetricsTest, ReportedUnsupportedLanguageAtInitiation) {
   const int ENGLISH = 25966;
 
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::
-          UMA_UNSUPPORTED_LANGUAGE_AT_INITIATION));
+  MetricsRecorder recorder("Translate.UnsupportedLanguageAtInitiation");
   EXPECT_EQ(0, recorder.GetTotalCount());
   translate::TranslateBrowserMetrics::ReportUnsupportedLanguageAtInitiation(
       "en");
@@ -289,8 +283,7 @@ TEST(TranslateBrowserMetricsTest, ReportedTranslateSourceLanguage) {
   const int ENGLISH = -74147910;
   const int FRENCH = 1704315002;
 
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_TRANSLATE_SOURCE_LANGUAGE));
+  MetricsRecorder recorder("Translate.SourceLanguage");
   EXPECT_EQ(0, recorder.GetTotalCount());
 
   translate::TranslateBrowserMetrics::ReportTranslateSourceLanguage("en");
@@ -305,8 +298,7 @@ TEST(TranslateBrowserMetricsTest, ReportedTranslateTargetLanguage) {
   const int ENGLISH = -74147910;
   const int FRENCH = 1704315002;
 
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_TRANSLATE_TARGET_LANGUAGE));
+  MetricsRecorder recorder("Translate.TargetLanguage");
   EXPECT_EQ(0, recorder.GetTotalCount());
 
   translate::TranslateBrowserMetrics::ReportTranslateTargetLanguage("en");
@@ -318,8 +310,7 @@ TEST(TranslateBrowserMetricsTest, ReportedTranslateTargetLanguage) {
 }
 
 TEST(TranslateBrowserMetricsTest, ReportTranslateHrefHintStatus) {
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::UMA_TRANSLATE_HREF_HINT_STATUS));
+  MetricsRecorder recorder("Translate.HrefHint.Status");
   recorder.CheckTranslateHrefHintStatus(0, 0, 0);
   translate::TranslateBrowserMetrics::ReportTranslateHrefHintStatus(
       translate::TranslateBrowserMetrics::HrefTranslateStatus::kAutoTranslated);
@@ -335,9 +326,7 @@ TEST(TranslateBrowserMetricsTest, ReportTranslateHrefHintStatus) {
 }
 
 TEST(TranslateBrowserMetricsTest, ReportTranslateTargetLanguageOrigin) {
-  MetricsRecorder recorder(translate::TranslateBrowserMetrics::GetMetricsName(
-      translate::TranslateBrowserMetrics::
-          UMA_TRANSLATE_TARGET_LANGUAGE_ORIGIN));
+  MetricsRecorder recorder("Translate.TargetLanguage.Origin");
   recorder.CheckTranslateTargetLanugageOrigin(0, 0, 0, 0, 0);
   translate::TranslateBrowserMetrics::ReportTranslateTargetLanguageOrigin(
       translate::TranslateBrowserMetrics::TargetLanguageOrigin::kRecentTarget);

components/translate/core/browser/translate_download_manager.cc

@@ -49,7 +49,7 @@ base::Time TranslateDownloadManager::GetSupportedLanguagesLastUpdated() {
 
 // static
 std::string TranslateDownloadManager::GetLanguageCode(
-    const std::string& language) {
+    base::StringPiece language) {
   TranslateLanguageList* language_list = GetInstance()->language_list();
   DCHECK(language_list);
 
@@ -57,8 +57,7 @@ std::string TranslateDownloadManager::GetLanguageCode(
 }
 
 // static
-bool TranslateDownloadManager::IsSupportedLanguage(
-    const std::string& language) {
+bool TranslateDownloadManager::IsSupportedLanguage(base::StringPiece language) {
   TranslateLanguageList* language_list = GetInstance()->language_list();
   DCHECK(language_list);
 

components/translate/core/browser/translate_download_manager.h

@@ -10,6 +10,7 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/sequence_checker.h"
+#include "base/strings/string_piece.h"
 #include "components/translate/core/browser/translate_language_list.h"
 #include "components/translate/core/browser/translate_script.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
@@ -60,9 +61,9 @@ class TranslateDownloadManager {
     return script_.get();
   }
 
-  // Fills |languages| with the list of languages that the translate server can
-  // translate to and from. May cause a language list request unless
-  // |translate_allowed| is false.
+  // Fills |languages| with the alphabetically sorted list of languages that the
+  // translate server can translate to and from. May cause a language list
+  // request unless |translate_allowed| is false.
   static void GetSupportedLanguages(bool translate_allowed,
                                     std::vector<std::string>* languages);
 
@@ -73,10 +74,10 @@ class TranslateDownloadManager {
   // Returns the language code that can be used with the Translate method for a
   // specified |language|. (ex. GetLanguageCode("en-US") will return "en", and
   // GetLanguageCode("zh-CN") returns "zh-CN")
-  static std::string GetLanguageCode(const std::string& language);
+  static std::string GetLanguageCode(base::StringPiece language);
 
   // Returns true if |language| is supported by the translation server.
-  static bool IsSupportedLanguage(const std::string& language);
+  static bool IsSupportedLanguage(base::StringPiece language);
 
   // Must be called to shut Translate down. Cancels any pending fetches.
   void Shutdown();

components/translate/core/browser/translate_event_details.cc

@@ -4,14 +4,16 @@
 
 #include "components/translate/core/browser/translate_event_details.h"
 
+#include <utility>
+
 namespace translate {
 
-TranslateEventDetails::TranslateEventDetails(const std::string& in_filename,
+TranslateEventDetails::TranslateEventDetails(std::string in_filename,
                                              int in_line,
-                                             const std::string& in_message)
-    : filename(in_filename),
+                                             std::string in_message)
+    : filename(std::move(in_filename)),
       line(in_line),
-      message(in_message) {
+      message(std::move(in_message)) {
   time = base::Time::Now();
 }
 

components/translate/core/browser/translate_event_details.h

@@ -12,9 +12,9 @@
 namespace translate {
 
 struct TranslateEventDetails {
-  TranslateEventDetails(const std::string& in_filename,
+  TranslateEventDetails(std::string in_filename,
                         int in_line,
-                        const std::string& in_message);
+                        std::string in_message);
 
   // The time when this event was created.
   base::Time time;

components/translate/core/browser/translate_language_list.h

@@ -6,13 +6,13 @@
 #define COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_LANGUAGE_LIST_H_
 
 #include <memory>
-#include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_list.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/strings/string_piece.h"
 #include "base/time/time.h"
 
 class GURL;
@@ -33,19 +33,19 @@ class TranslateLanguageList {
   // Translate server. Returns null time if the list is yet to be fetched.
   base::Time last_updated() { return last_updated_; }
 
-  // Fills |languages| with the list of languages that the translate server can
-  // translate to and from. May attempt a language list request unless
-  // |translate_allowed| is false.
+  // Fills |languages| with the alphabetically sorted list of languages that the
+  // translate server can translate to and from. May attempt a language list
+  // request unless |translate_allowed| is false.
   void GetSupportedLanguages(bool translate_allowed,
                              std::vector<std::string>* languages);
 
   // Returns the language code that can be used with the Translate method for a
   // specified |language|. (ex. GetLanguageCode("en-US") will return "en", and
   // GetLanguageCode("zh-CN") returns "zh-CN")
-  std::string GetLanguageCode(const std::string& language);
+  std::string GetLanguageCode(base::StringPiece language);
 
   // Returns true if |language| is supported by the translation server.
-  bool IsSupportedLanguage(const std::string& language);
+  bool IsSupportedLanguage(base::StringPiece language);
 
   // Fetches the language list from the translate server if resource requests
   // are allowed, and otherwise keeps the request as pending until allowed.
@@ -86,15 +86,15 @@ class TranslateLanguageList {
   void OnLanguageListFetchComplete(bool success, const std::string& data);
 
   // Notifies the callback list of a translate event.
-  void NotifyEvent(int line, const std::string& message);
+  void NotifyEvent(int line, std::string message);
 
   // Parses |language_list| containing the list of languages that the translate
   // server can translate to and from. Returns true iff the list is parsed
   // without syntax errors.
-  bool SetSupportedLanguages(const std::string& language_list);
+  bool SetSupportedLanguages(base::StringPiece language_list);
 
   // Returns the url from which to load the list of languages.
-  GURL TranslateLanguageUrl();
+  static GURL TranslateLanguageUrl();
 
   // Callbacks called on translate events.
   EventCallbackList callback_list_;
@@ -105,8 +105,8 @@ class TranslateLanguageList {
   // True if the list has to be fetched when resource requests are allowed.
   bool request_pending_;
 
-  // The languages supported by the translation server.
-  std::set<std::string> supported_languages_;
+  // The languages supported by the translation server, sorted alphabetically.
+  std::vector<std::string> supported_languages_;
 
   // A LanguageListFetcher instance to fetch a server providing supported
   // language list.

components/translate/core/browser/translate_prefs.cc

@@ -54,6 +54,30 @@ bool ContainsSameBaseLanguage(const std::vector<std::string>& list,
   return false;
 }
 
+// Removes from the language list any language that isn't supported as an
+// Accept-Language (it's not in kAcceptLanguageList) if and only if there
+// aren't any other languages from the same family in the list that are
+// supported.
+void PurgeUnsupportedLanguagesInLanguageFamily(base::StringPiece language,
+                                               std::vector<std::string>* list) {
+  base::StringPiece base_language = language::ExtractBaseLanguage(language);
+  for (const auto& lang : *list) {
+    // This method only operates on languages in the same family as |language|.
+    if (base_language != language::ExtractBaseLanguage(lang))
+      continue;
+    // If at least one of these same-family languages in |list| is supported by
+    // Accept-Languages, then that means that none of the languages in this
+    // family should be purged.
+    if (TranslateAcceptLanguages::CanBeAcceptLanguage(lang))
+      return;
+  }
+
+  // Purge all languages in the same family as |language|.
+  base::EraseIf(*list, [base_language](const std::string& lang) {
+    return base_language == language::ExtractBaseLanguage(lang);
+  });
+}
+
 }  // namespace
 
 const char kForceTriggerTranslateCount[] =
@@ -403,11 +427,14 @@ void TranslatePrefs::GetLanguageInfoList(
         std::move(code);
   }
 
-  // Get the list of translatable languages and sort it for fast searching.
+  // Get the sorted list of translatable languages.
   std::vector<std::string> translate_languages;
   translate::TranslateDownloadManager::GetSupportedLanguages(
       translate_allowed, &translate_languages);
-  std::sort(translate_languages.begin(), translate_languages.end());
+  // |translate_languages| should already be sorted alphabetically for fast
+  // searching.
+  DCHECK(
+      std::is_sorted(translate_languages.begin(), translate_languages.end()));
 
   // Build the language list from the language map.
   for (auto& entry : language_map) {
@@ -925,25 +952,4 @@ bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
   return (dict == nullptr || dict->empty());
 }
 
-void TranslatePrefs::PurgeUnsupportedLanguagesInLanguageFamily(
-    base::StringPiece language,
-    std::vector<std::string>* list) {
-  base::StringPiece base_language = language::ExtractBaseLanguage(language);
-  for (const auto& lang : *list) {
-    // This method only operates on languages in the same family as |language|.
-    if (base_language != language::ExtractBaseLanguage(lang))
-      continue;
-    // If at least one of these same-family languages in |list| is supported by
-    // Accept-Languages, then that means that none of the languages in this
-    // family should be purged.
-    if (TranslateAcceptLanguages::CanBeAcceptLanguage(lang))
-      return;
-  }
-
-  // Purge all languages in the same family as |language|.
-  base::EraseIf(*list, [base_language](const std::string& lang) {
-    return base_language == language::ExtractBaseLanguage(lang);
-  });
-}
-
 }  // namespace translate

components/translate/core/browser/translate_prefs.h

@@ -363,13 +363,6 @@ class TranslatePrefs {
   size_t GetListSize(const char* pref_id) const;
 
   bool IsDictionaryEmpty(const char* pref_id) const;
-  // Removes from the language list any language that isn't supported as an
-  // Accept-Language (it's not in kAcceptLanguageList) if and only if there
-  // aren't any other languages from the same family in the list that are
-  // supported.
-  void PurgeUnsupportedLanguagesInLanguageFamily(
-      base::StringPiece language,
-      std::vector<std::string>* list);
 
   // Path to the preference storing the accept languages.
   const std::string accept_languages_pref_;