Rename WebApplicationCacheHostImpl::IsNewMasterEntry enum to not use YES/NO.

content/child/appcache/web_application_cache_host_impl.cc

 // Copyright 2013 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 "content/child/appcache/web_application_cache_host_impl.h"
 
 #include <stddef.h>
 
 #include "base/compiler_specific.h"
 #include "base/id_map.h"
@@ skipping 47 matching lines @@
 
 WebApplicationCacheHostImpl::WebApplicationCacheHostImpl(
     WebApplicationCacheHostClient* client,
     AppCacheBackend* backend,
     int appcache_host_id)
     : client_(client),
       backend_(backend),
       status_(APPCACHE_STATUS_UNCACHED),
       is_scheme_supported_(false),
       is_get_method_(false),
-      is_new_master_entry_(MAYBE),
+      is_new_master_entry_(MAYBE_NEW_ENTRY),
       was_select_cache_called_(false) {
   DCHECK(client && backend);
   // PlzNavigate: The browser passes the ID to be used.
   if (appcache_host_id != kAppCacheNoHostId) {
     DCHECK(IsBrowserSideNavigationEnabled());
     all_hosts()->AddWithID(this, appcache_host_id);
     host_id_ = appcache_host_id;
   } else {
     host_id_ = all_hosts()->Add(this);
   }
@@ skipping 115 matching lines @@
   request.setAppCacheHostID(host_id_);
 }
 
 void WebApplicationCacheHostImpl::selectCacheWithoutManifest() {
   if (was_select_cache_called_)
     return;
   was_select_cache_called_ = true;
 
   status_ = (document_response_.appCacheID() == kAppCacheNoCacheId) ?
       APPCACHE_STATUS_UNCACHED : APPCACHE_STATUS_CHECKING;
-  is_new_master_entry_ = NO;
+  is_new_master_entry_ = OLD_ENTRY;

[michaeln, 2017/02/03 00:43:55]

would MAYBE, YUP, NOPE be more readable?

lgtm

[Patti Lor, 2017/02/03 01:08:14]

Yeah, I was also a bit worried about losing a bit of readability. I think with
NEW_ENTRY/OLD_ENTRY though we can avoid future devs reading the code and
wondering why "YUP/NOPE" were used instead of "YES/NO" and trying to change it.

   backend_->SelectCache(host_id_, document_url_,
                         document_response_.appCacheID(),
                         GURL());
 }
 
 bool WebApplicationCacheHostImpl::selectCacheWithManifest(
     const WebURL& manifest_url) {
   if (was_select_cache_called_)
     return true;
   was_select_cache_called_ = true;
 
   GURL manifest_gurl(ClearUrlRef(manifest_url));
 
   // 6.9.6 The application cache selection algorithm
   // Check for new 'master' entries.
   if (document_response_.appCacheID() == kAppCacheNoCacheId) {
     if (is_scheme_supported_ && is_get_method_ &&
         (manifest_gurl.GetOrigin() == document_url_.GetOrigin())) {
       status_ = APPCACHE_STATUS_CHECKING;
-      is_new_master_entry_ = YES;
+      is_new_master_entry_ = NEW_ENTRY;
     } else {
       status_ = APPCACHE_STATUS_UNCACHED;
-      is_new_master_entry_ = NO;
+      is_new_master_entry_ = OLD_ENTRY;
       manifest_gurl = GURL();
     }
     backend_->SelectCache(
         host_id_, document_url_, kAppCacheNoCacheId, manifest_gurl);
     return true;
   }
 
-  DCHECK_EQ(NO, is_new_master_entry_);
+  DCHECK_EQ(OLD_ENTRY, is_new_master_entry_);
 
   // 6.9.6 The application cache selection algorithm
   // Check for 'foreign' entries.
   GURL document_manifest_gurl(document_response_.appCacheManifestURL());
   if (document_manifest_gurl != manifest_gurl) {
     backend_->MarkAsForeignEntry(host_id_, document_url_,
                                  document_response_.appCacheID());
     status_ = APPCACHE_STATUS_UNCACHED;
     return false;  // the navigation will be restarted
   }
@@ skipping 11 matching lines @@
     const WebURLResponse& response) {
   document_response_ = response;
   document_url_ = ClearUrlRef(document_response_.url());
   if (document_url_ != original_main_resource_url_)
     is_get_method_ = true;  // A redirect was involved.
   original_main_resource_url_ = GURL();
 
   is_scheme_supported_ =  IsSchemeSupportedForAppCache(document_url_);
   if ((document_response_.appCacheID() != kAppCacheNoCacheId) ||
       !is_scheme_supported_ || !is_get_method_)
-    is_new_master_entry_ = NO;
+    is_new_master_entry_ = OLD_ENTRY;
 }
 
 void WebApplicationCacheHostImpl::didReceiveDataForMainResource(
     const char* data, unsigned len) {
-  if (is_new_master_entry_ == NO)
+  if (is_new_master_entry_ == OLD_ENTRY)
     return;
   // TODO(michaeln): write me
 }
 
 void WebApplicationCacheHostImpl::didFinishLoadingMainResource(bool success) {
-  if (is_new_master_entry_ == NO)
+  if (is_new_master_entry_ == OLD_ENTRY)
     return;
   // TODO(michaeln): write me
 }
 
 WebApplicationCacheHost::Status WebApplicationCacheHostImpl::getStatus() {
   return static_cast<WebApplicationCacheHost::Status>(status_);
 }
 
 bool WebApplicationCacheHostImpl::startUpdate() {
   if (!backend_->StartUpdate(host_id_))
@@ skipping 37 matching lines @@
     web_resources[i].isExplicit = resource_infos[i].is_explicit;
     web_resources[i].isManifest = resource_infos[i].is_manifest;
     web_resources[i].isForeign = resource_infos[i].is_foreign;
     web_resources[i].isFallback = resource_infos[i].is_fallback;
     web_resources[i].url = resource_infos[i].url;
   }
   resources->swap(web_resources);
 }
 
 }  // namespace content