Add net logging for ServiceWorkerURLRequestJob.

content/browser/service_worker/service_worker_url_request_job.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_url_request_job.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 16 matching lines @@
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
+#include "net/log/net_log.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
+namespace {
+
+net::NetLog::EventType RequestJobResultToNetEventType(
+    ServiceWorkerMetrics::URLRequestJobResult result) {
+  using n = net::NetLog;
+  using m = ServiceWorkerMetrics;
+  switch (result) {
+    case m::REQUEST_JOB_FALLBACK_RESPONSE:
+      return n::TYPE_SERVICE_WORKER_FALLBACK_RESPONSE;
+    case m::REQUEST_JOB_FALLBACK_FOR_CORS:
+      return n::TYPE_SERVICE_WORKER_FALLBACK_FOR_CORS;
+    case m::REQUEST_JOB_HEADERS_ONLY_RESPONSE:
+      return n::TYPE_SERVICE_WORKER_HEADERS_ONLY_RESPONSE;
+    case m::REQUEST_JOB_STREAM_RESPONSE:
+      return n::TYPE_SERVICE_WORKER_STREAM_RESPONSE;
+    case m::REQUEST_JOB_BLOB_RESPONSE:
+      return n::TYPE_SERVICE_WORKER_BLOB_RESPONSE;
+    case m::REQUEST_JOB_ERROR_RESPONSE_STATUS_ZERO:
+      return n::TYPE_SERVICE_WORKER_ERROR_RESPONSE_STATUS_ZERO;
+    case m::REQUEST_JOB_ERROR_BAD_BLOB:
+      return n::TYPE_SERVICE_WORKER_ERROR_BAD_BLOB;
+    case m::REQUEST_JOB_ERROR_NO_PROVIDER_HOST:
+      return n::TYPE_SERVICE_WORKER_ERROR_NO_PROVIDER_HOST;
+    case m::REQUEST_JOB_ERROR_NO_ACTIVE_VERSION:
+      return n::TYPE_SERVICE_WORKER_ERROR_NO_ACTIVE_VERSION;
+    case m::REQUEST_JOB_ERROR_FETCH_EVENT_DISPATCH:
+      return n::TYPE_SERVICE_WORKER_ERROR_FETCH_EVENT_DISPATCH;
+    case m::REQUEST_JOB_ERROR_BLOB_READ:
+      return n::TYPE_SERVICE_WORKER_ERROR_BLOB_READ;
+    case m::REQUEST_JOB_ERROR_STREAM_ABORTED:
+      return n::TYPE_SERVICE_WORKER_ERROR_STREAM_ABORTED;
+    case m::REQUEST_JOB_ERROR_KILLED:
+      return n::TYPE_SERVICE_WORKER_ERROR_KILLED;
+    case m::REQUEST_JOB_ERROR_KILLED_WITH_BLOB:
+      return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_BLOB;
+    case m::REQUEST_JOB_ERROR_KILLED_WITH_STREAM:
+      return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_STREAM;
+    // We can't log if there's no request; fallthrough.
+    case m::REQUEST_JOB_ERROR_NO_REQUEST:
+    // Obsolete types; fallthrough.
+    case m::REQUEST_JOB_ERROR_DESTROYED:
+    case m::REQUEST_JOB_ERROR_DESTROYED_WITH_BLOB:
+    case m::REQUEST_JOB_ERROR_DESTROYED_WITH_STREAM:
+    // Invalid type.
+    case m::NUM_REQUEST_JOB_RESULT_TYPES:
+      NOTREACHED() << result;
+  }
+  NOTREACHED() << result;
+  return n::TYPE_FAILED;
+}
+
+}  // namespace
+
 ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     const ResourceContext* resource_context,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     bool is_main_resource_load,
     RequestContextType request_context_type,
@@ skipping 28 matching lines @@
   response_type_ = FORWARD_TO_SERVICE_WORKER;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::Start() {
   is_started_ = true;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::Kill() {
-  if (ShouldRecordResult()) {
-    ServiceWorkerMetrics::URLRequestJobResult result =
-        ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED;
-    if (response_body_type_ == STREAM)
-      result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_STREAM;
-    else if (response_body_type_ == BLOB)
-      result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_BLOB;
-    RecordResult(result);
-  }
-
   net::URLRequestJob::Kill();
   ClearStream();
   fetch_dispatcher_.reset();
   blob_request_.reset();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 net::LoadState ServiceWorkerURLRequestJob::GetLoadState() const {
   // TODO(kinuko): refine this for better debug.
   return net::URLRequestJob::GetLoadState();
@@ skipping 231 matching lines @@
   response_info->service_worker_start_time = worker_start_time_;
   response_info->service_worker_ready_time = worker_ready_time_;
 }
 
 
 ServiceWorkerURLRequestJob::~ServiceWorkerURLRequestJob() {
   ClearStream();
 
   if (!ShouldRecordResult())
     return;
-  // TODO(falken): If we don't see many of these, we might merge KILLED and
-  // DESTROYED results together.
   ServiceWorkerMetrics::URLRequestJobResult result =
-      ServiceWorkerMetrics::REQUEST_JOB_ERROR_DESTROYED;
+      ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED;
   if (response_body_type_ == STREAM)
-    result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_DESTROYED_WITH_STREAM;
+    result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_STREAM;
   else if (response_body_type_ == BLOB)
-    result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_DESTROYED_WITH_BLOB;
+    result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_BLOB;
   RecordResult(result);
 }
 
 void ServiceWorkerURLRequestJob::MaybeStartRequest() {
   if (is_started_ && response_type_ != NOT_DETERMINED) {
     // Start asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ServiceWorkerURLRequestJob::StartRequest,
                               weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerURLRequestJob::StartRequest() {
+  if (request()) {

[falken, 2015/07/10 01:10:18]

Added this check: it looks conceivable for request() to be null here since this
function is called asynchronously. Since I'm landing close to branch and might
merge to 44, I really want this patch to just add  logging and have no possible
behavior change.

+    request()->net_log().AddEvent(
+        net::NetLog::TYPE_SERVICE_WORKER_START_REQUEST);
+  }
+
   switch (response_type_) {
     case NOT_DETERMINED:
       NOTREACHED();
       return;
 
     case FALLBACK_TO_NETWORK:
       // Restart the request to create a new job. Our request handler will
       // return nullptr, and the default job (which will hit network) should be
       // created.
       NotifyRestartRequired();
@@ skipping 330 matching lines @@
     ServiceWorkerMetrics::URLRequestJobResult result) {
   // It violates style guidelines to handle a NOTREACHED() failure but if there
   // is a bug don't let it corrupt UMA results by double-counting.
   if (!ShouldRecordResult()) {
     NOTREACHED();
     return;
   }
   did_record_result_ = true;
   ServiceWorkerMetrics::RecordURLRequestJobResult(is_main_resource_load_,
                                                   result);
+  if (request())
+    request()->net_log().AddEvent(RequestJobResultToNetEventType(result));
 }
 
 void ServiceWorkerURLRequestJob::RecordStatusZeroResponseError(
     blink::WebServiceWorkerResponseError error) {
   // It violates style guidelines to handle a NOTREACHED() failure but if there
   // is a bug don't let it corrupt UMA results by double-counting.
   if (!ShouldRecordResult()) {
     NOTREACHED();
     return;
   }
@@ skipping 14 matching lines @@
   }
   if (!waiting_stream_url_.is_empty()) {
     StreamRegistry* stream_registry =
         GetStreamContextForResourceContext(resource_context_)->registry();
     stream_registry->RemoveRegisterObserver(waiting_stream_url_);
     stream_registry->AbortPendingStream(waiting_stream_url_);
   }
 }
 
 }  // namespace content