Introduce ServiceWorker.MainFramePageLoad.CoreTransition and RedirectChainLength UMAs.

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>
 
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/load_flags.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
+#include "ui/base/page_transition_types.h"
 
 namespace content {
 
 namespace {
 
 bool MaybeForwardToServiceWorker(ServiceWorkerURLRequestJob* job,
                                  const ServiceWorkerVersion* version) {
   DCHECK(job);
   DCHECK(version);
   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;
 }
 
+ui::PageTransition GetPageTransition(net::URLRequest* request) {
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+  // ResourceRequestInfo may not be set in some tests.
+  if (!info)
+    return ui::PAGE_TRANSITION_LINK;
+  return info->GetPageTransition();
+}
+
 }  // namespace
 
 ServiceWorkerControlleeRequestHandler::ServiceWorkerControlleeRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
     ResourceType resource_type,
@@ skipping 220 matching lines @@
         "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(
-      active_version->site_for_uma(), stripped_url_, is_main_frame_load_);
+      active_version->site_for_uma(), stripped_url_, is_main_frame_load_,
+      GetPageTransition(job_->request()), job_->request()->url_chain().size());
 
   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");
@@ skipping 11 matching lines @@
   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(
-      version->site_for_uma(), stripped_url_, is_main_frame_load_);
+      version->site_for_uma(), stripped_url_, is_main_frame_load_,
+      GetPageTransition(job_->request()), job_->request()->url_chain().size());
 
   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