Rename ShouldUpdateHistoryResult enum values to not use NO.

chrome/browser/download/download_history.cc

 // Copyright (c) 2012 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.
 
 // DownloadHistory manages persisting DownloadItems to the history service by
 // observing a single DownloadManager and all its DownloadItems using an
 // AllDownloadItemNotifier.
 //
 // DownloadHistory decides whether and when to add items to, remove items from,
 // and update items in the database. DownloadHistory uses DownloadHistoryData to
@@ skipping 126 matching lines @@
       item->GetReceivedBytes(), item->GetTotalBytes(),
       history::ToHistoryDownloadState(item->GetState()),
       history::ToHistoryDownloadDangerType(item->GetDangerType()),
       history::ToHistoryDownloadInterruptReason(item->GetLastReason()),
       std::string(),  // Hash value (not available yet)
       history::ToHistoryDownloadId(item->GetId()), item->GetGuid(),
       item->GetOpened(), by_ext_id, by_ext_name);
 }
 
 enum class ShouldUpdateHistoryResult {
-    NO,
-    UPDATE,
-    UPDATE_IMMEDIATELY,
+  NO_UPDATE,
+  UPDATE,
+  UPDATE_IMMEDIATELY,
 };
 
 ShouldUpdateHistoryResult ShouldUpdateHistory(
     const history::DownloadRow* previous,
     const history::DownloadRow& current) {
   // When download path is determined, Chrome should commit the history
   // immediately. Otherwise the file will be left permanently on the external
   // storage if Chrome crashes right away.
   // TODO(qinmin): this doesn't solve all the issues. When download starts,
   // Chrome will write the http response data to a temporary file, and later
@@ skipping 14 matching lines @@
       (previous->state != current.state) ||
       (previous->danger_type != current.danger_type) ||
       (previous->interrupt_reason != current.interrupt_reason) ||
       (previous->hash != current.hash) ||
       (previous->opened != current.opened) ||
       (previous->by_ext_id != current.by_ext_id) ||
       (previous->by_ext_name != current.by_ext_name)) {
     return ShouldUpdateHistoryResult::UPDATE;
   }
 
-  return ShouldUpdateHistoryResult::NO;
+  return ShouldUpdateHistoryResult::NO_UPDATE;
 }
 
 typedef std::vector<history::DownloadRow> InfoVector;
 
 }  // anonymous namespace
 
 DownloadHistory::HistoryAdapter::HistoryAdapter(
     history::HistoryService* history)
     : history_(history) {
 }
@@ skipping 228 matching lines @@
     return;
   }
   if (item->IsTemporary()) {
     OnDownloadRemoved(notifier_.GetManager(), item);
     return;
   }
 
   history::DownloadRow current_info(GetDownloadRow(item));
   ShouldUpdateHistoryResult should_update_result =
       ShouldUpdateHistory(data->info(), current_info);
-  bool should_update = (should_update_result != ShouldUpdateHistoryResult::NO);
+  bool should_update =
+      (should_update_result != ShouldUpdateHistoryResult::NO_UPDATE);
   UMA_HISTOGRAM_ENUMERATION("Download.HistoryPropagatedUpdate",
                             should_update, 2);
   if (should_update) {
     history_->UpdateDownload(
         current_info,
         should_update_result == ShouldUpdateHistoryResult::UPDATE_IMMEDIATELY);
     for (Observer& observer : observers_)
       observer.OnDownloadStored(item, current_info);
   }
   if (item->GetState() == content::DownloadItem::IN_PROGRESS) {
@@ skipping 44 matching lines @@
 }
 
 void DownloadHistory::RemoveDownloadsBatch() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   IdSet remove_ids;
   removing_ids_.swap(remove_ids);
   history_->RemoveDownloads(remove_ids);
   for (Observer& observer : observers_)
     observer.OnDownloadsRemoved(remove_ids);
 }