Use tri-state enum for the existence of Fetch Handler in ServiceWorkerVersion.

content/browser/service_worker/service_worker_controllee_request_handler.cc

 // Copyright 2014 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/browser/service_worker/service_worker_controllee_request_handler.h"
 
 #include <memory>
 #include <set>
 #include <string>
 
@@ skipping 15 matching lines @@
 #include "net/url_request/url_request.h"
 
 namespace content {
 
 namespace {
 
 bool MaybeForwardToServiceWorker(ServiceWorkerURLRequestJob* job,
                                  const ServiceWorkerVersion* version) {
   DCHECK(job);
   DCHECK(version);
-  if (version->has_fetch_handler()) {
+  DCHECK_NE(version->fetch_handler_existence(),
+            ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
+  if (version->fetch_handler_existence() ==
+      ServiceWorkerVersion::FetchHandlerExistence::EXISTS) {
     job->ForwardToServiceWorker();
     return true;
   }
 
   job->FallbackToNetworkOrRenderer();
   return false;
 }
 
 }  // namespace
 
@@ skipping 226 matching lines @@
     TRACE_EVENT_ASYNC_END2(
         "ServiceWorker",
         "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
         job_.get(),
         "Status", status,
         "Info",
         "ServiceWorkerVersion is not available, so falling back to network");
     return;
   }
 
+  DCHECK_NE(active_version->fetch_handler_existence(),
+            ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
+
   ServiceWorkerMetrics::CountControlledPageLoad(
-      stripped_url_, active_version->has_fetch_handler(), is_main_frame_load_);
+      stripped_url_, active_version->fetch_handler_existence() ==
+                         ServiceWorkerVersion::FetchHandlerExistence::EXISTS,
+      is_main_frame_load_);
 
   bool is_forwarded =
       MaybeForwardToServiceWorker(job_.get(), active_version.get());
 
   TRACE_EVENT_ASYNC_END2(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
       job_.get(), "Status", status, "Info",
       (is_forwarded) ? "Forwarded to the ServiceWorker"
                      : "Skipped the ServiceWorker which has no fetch handler");
 }
 
 void ServiceWorkerControlleeRequestHandler::OnVersionStatusChanged(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version) {
   // The job may have been canceled and then destroyed before this was invoked.
   if (!job_)
     return;
 
   if (provider_host_)
     provider_host_->SetAllowAssociation(true);
   if (version != registration->active_version() ||
       version->status() != ServiceWorkerVersion::ACTIVATED ||
       !provider_host_) {
     job_->FallbackToNetwork();
     return;
   }
 
+  DCHECK_NE(version->fetch_handler_existence(),
+            ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
   ServiceWorkerMetrics::CountControlledPageLoad(
-      stripped_url_, version->has_fetch_handler(), is_main_frame_load_);
+      stripped_url_, version->fetch_handler_existence() ==
+                         ServiceWorkerVersion::FetchHandlerExistence::EXISTS,
+      is_main_frame_load_);
 
   provider_host_->AssociateRegistration(registration,
                                         false /* notify_controllerchange */);
 
   MaybeForwardToServiceWorker(job_.get(), version);
 }
 
 void ServiceWorkerControlleeRequestHandler::DidUpdateRegistration(
     const scoped_refptr<ServiceWorkerRegistration>& original_registration,
     ServiceWorkerStatusCode status,
@@ skipping 98 matching lines @@
   DCHECK(provider_host_);
   // Detach the controller so subresource requests also skip the worker.
   provider_host_->NotifyControllerLost();
 }
 
 void ServiceWorkerControlleeRequestHandler::ClearJob() {
   job_.reset();
 }
 
 }  // namespace content