Make OutputDeveloperMessageCode an enum class

chrome/browser/banners/app_banner_data_fetcher.cc

 // Copyright 2015 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/banners/app_banner_data_fetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 172 matching lines @@
   // The redisplay request may be received before the Cancel prompt reply
   // *after* if it is made before the beforeinstallprompt event handler
   // concludes (e.g. in the event handler itself), so allow the pipeline
   // to continue in this case.
   //
   // Stash the referrer for the case where the banner is redisplayed.
   if (reply == blink::WebAppBannerPromptReply::Cancel &&
       !page_requested_prompt_) {
     was_canceled_by_page_ = true;
     referrer_ = referrer;
-    OutputDeveloperNotShownMessage(web_contents, kRendererRequestCancel,
-                                   is_debug_mode_);
+    OutputDeveloperNotShownMessage(
+        web_contents, OutputDeveloperMessageCode::kRendererRequestCancel,
+        is_debug_mode_);
     return;
   }
 
   AppBannerSettingsHelper::RecordMinutesFromFirstVisitToShow(
       web_contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 
   // Definitely going to show the banner now.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnDecidedWhetherToShow(this, true));
 
@@ skipping 45 matching lines @@
   rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
                                           event_name,
                                           web_contents->GetURL());
 }
 
 void AppBannerDataFetcher::OnDidHasManifest(bool has_manifest) {
   content::WebContents* web_contents = GetWebContents();
 
   if (!CheckFetcherIsStillAlive(web_contents) || !has_manifest) {
     if (!has_manifest)
-      OutputDeveloperNotShownMessage(web_contents, kNoManifest, is_debug_mode_);
+      OutputDeveloperNotShownMessage(web_contents,
+                                     OutputDeveloperMessageCode::kNoManifest,
+                                     is_debug_mode_);
 
     Cancel();
     return;
   }
 
   web_contents->GetManifest(
       base::Bind(&AppBannerDataFetcher::OnDidGetManifest, this));
 }
 
 void AppBannerDataFetcher::OnDidGetManifest(
     const GURL& manifest_url,
     const content::Manifest& manifest) {
   content::WebContents* web_contents = GetWebContents();
   if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
   if (manifest.IsEmpty()) {
-    OutputDeveloperNotShownMessage(web_contents, kManifestEmpty,
+    OutputDeveloperNotShownMessage(web_contents,
+                                   OutputDeveloperMessageCode::kManifestEmpty,
                                    is_debug_mode_);
     Cancel();
     return;
   }
 
   if (manifest.prefer_related_applications &&
       manifest.related_applications.size()) {
     for (const auto& application : manifest.related_applications) {
       std::string platform = base::UTF16ToUTF8(application.platform.string());
       std::string id = base::UTF16ToUTF8(application.id.string());
@@ skipping 42 matching lines @@
 void AppBannerDataFetcher::OnDidCheckHasServiceWorker(
     bool has_service_worker) {
   content::WebContents* web_contents = GetWebContents();
   if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
 
   if (!has_service_worker) {
     TrackDisplayEvent(DISPLAY_EVENT_LACKS_SERVICE_WORKER);
-    OutputDeveloperNotShownMessage(web_contents, kNoMatchingServiceWorker,
-                                   is_debug_mode_);
+    OutputDeveloperNotShownMessage(
+        web_contents, OutputDeveloperMessageCode::kNoMatchingServiceWorker,
+        is_debug_mode_);
     Cancel();
     return;
   }
 
   OnHasServiceWorker(web_contents);
 }
 
 void AppBannerDataFetcher::OnHasServiceWorker(
     content::WebContents* web_contents) {
   GURL icon_url = ManifestIconSelector::FindBestMatchingIcon(
       manifest_.icons, ideal_icon_size_in_dp_, minimum_icon_size_in_dp_);
 
   if (icon_url.is_empty()) {
     OutputDeveloperNotShownMessage(
         web_contents,
-        kNoIconMatchingRequirements,
+        OutputDeveloperMessageCode::kNoIconMatchingRequirements,
         base::IntToString(ManifestIconSelector::ConvertIconSizeFromDpToPx(
             minimum_icon_size_in_dp_)),
         is_debug_mode_);
     Cancel();
   } else if (!FetchAppIcon(web_contents, icon_url)) {
-    OutputDeveloperNotShownMessage(web_contents, kCannotDownloadIcon,
-                                   is_debug_mode_);
+    OutputDeveloperNotShownMessage(
+        web_contents, OutputDeveloperMessageCode::kCannotDownloadIcon,
+        is_debug_mode_);
     Cancel();
   }
 }
 
 bool AppBannerDataFetcher::FetchAppIcon(content::WebContents* web_contents,
                                         const GURL& icon_url) {
   app_icon_url_ = icon_url;
   return ManifestIconDownloader::Download(
       web_contents, icon_url, ideal_icon_size_in_dp_, minimum_icon_size_in_dp_,
       base::Bind(&AppBannerDataFetcher::OnAppIconFetched, this));
 }
 
 void AppBannerDataFetcher::OnAppIconFetched(const SkBitmap& bitmap) {
   if (!is_active_) return;
 
   content::WebContents* web_contents = GetWebContents();
   if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
   if (bitmap.drawsNothing()) {
-    OutputDeveloperNotShownMessage(web_contents, kNoIconAvailable,
+    OutputDeveloperNotShownMessage(web_contents,
+                                   OutputDeveloperMessageCode::kNoIconAvailable,
                                    is_debug_mode_);
     Cancel();
     return;
   }
 
   RecordCouldShowBanner();
   if (!is_debug_mode_ && !CheckIfShouldShowBanner()) {
     // At this point, the only possible case is that the banner has been added
     // to the homescreen, given all of the other checks that have been made.
     Cancel();
@@ skipping 29 matching lines @@
   DCHECK(web_contents);
 
   return AppBannerSettingsHelper::ShouldShowBanner(
       web_contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 }
 
 bool AppBannerDataFetcher::CheckFetcherIsStillAlive(
     content::WebContents* web_contents) {
   if (!is_active_) {
     OutputDeveloperNotShownMessage(
-        web_contents, kUserNavigatedBeforeBannerShown, is_debug_mode_);
+        web_contents,
+        OutputDeveloperMessageCode::kUserNavigatedBeforeBannerShown,
+        is_debug_mode_);
     return false;
   }
   if (!web_contents) {
     return false; // We cannot show a message if |web_contents| is null
   }
   return true;
 }
 
 // static
 bool AppBannerDataFetcher::IsManifestValidForWebApp(
     const content::Manifest& manifest,
     content::WebContents* web_contents,
     bool is_debug_mode) {
   if (manifest.IsEmpty()) {
-    OutputDeveloperNotShownMessage(web_contents, kManifestEmpty, is_debug_mode);
+    OutputDeveloperNotShownMessage(web_contents,
+                                   OutputDeveloperMessageCode::kManifestEmpty,
+                                   is_debug_mode);
     return false;
   }
   if (!manifest.start_url.is_valid()) {
-    OutputDeveloperNotShownMessage(web_contents, kStartURLNotValid,
-                                   is_debug_mode);
+    OutputDeveloperNotShownMessage(
+        web_contents, OutputDeveloperMessageCode::kStartURLNotValid,
+        is_debug_mode);
     return false;
   }
   if ((manifest.name.is_null() || manifest.name.string().empty()) &&
       (manifest.short_name.is_null() || manifest.short_name.string().empty())) {
     OutputDeveloperNotShownMessage(
-        web_contents, kManifestMissingNameOrShortName, is_debug_mode);
+        web_contents,
+        OutputDeveloperMessageCode::kManifestMissingNameOrShortName,
+        is_debug_mode);
     return false;
   }
 
   // TODO(dominickn,mlamouri): when Chrome supports "minimal-ui", it should be
   // accepted. If we accept it today, it would fallback to "browser" and make
   // this check moot. See https://crbug.com/604390
   if (manifest.display != blink::WebDisplayModeStandalone &&
       manifest.display != blink::WebDisplayModeFullscreen) {
     OutputDeveloperNotShownMessage(
-        web_contents, kManifestDisplayStandaloneFullscreen, is_debug_mode);
+        web_contents,
+        OutputDeveloperMessageCode::kManifestDisplayStandaloneFullscreen,
+        is_debug_mode);
     return false;
   }
 
   if (!DoesManifestContainRequiredIcon(manifest)) {
-    OutputDeveloperNotShownMessage(web_contents, kManifestMissingSuitableIcon,
-                                   is_debug_mode);
+    OutputDeveloperNotShownMessage(
+        web_contents, OutputDeveloperMessageCode::kManifestMissingSuitableIcon,
+        is_debug_mode);
     return false;
   }
   return true;
 }
 
 }  // namespace banners