service worker: Attribute purpose to start worker attempts for UMA

content/browser/service_worker/service_worker_browsertest.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 <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/referrer.h"
+#include "content/public/common/resource_type.h"
 #include "content/public/common/security_style.h"
 #include "content/public/common/ssl_status.h"
 #include "content/public/common/web_preferences.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/test/test_content_browser_client.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
@@ skipping 540 matching lines @@
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->StartWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void InstallOnIOThread(const base::Closure& done,
                          ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::INSTALLING);
     version_->RunAfterStartWorker(
         base::Bind(&self::DispatchInstallEventOnIOThread, this, done, result),
-        CreateReceiver(BrowserThread::UI, done, result));
+        CreateReceiver(BrowserThread::UI, done, result),
+        ServiceWorkerMetrics::EventType::INSTALL);
   }
 
   void DispatchInstallEventOnIOThread(const base::Closure& done,
                                       ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     int request_id =
         version_->StartRequest(ServiceWorkerMetrics::EventType::INSTALL,
                                CreateReceiver(BrowserThread::UI, done, result));
     version_->DispatchSimpleEvent<ServiceWorkerHostMsg_InstallEventFinished>(
         request_id, ServiceWorkerMsg_InstallEvent(request_id));
@@ skipping 10 matching lines @@
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void ActivateOnIOThread(const base::Closure& done,
                           ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
     registration_->SetActiveVersion(version_.get());
     version_->RunAfterStartWorker(
         base::Bind(&self::DispatchActivateEventOnIOThread, this, done, result),
-        CreateReceiver(BrowserThread::UI, done, result));
+        CreateReceiver(BrowserThread::UI, done, result),
+        ServiceWorkerMetrics::EventType::ACTIVATE);
   }
 
   void DispatchActivateEventOnIOThread(const base::Closure& done,
                                        ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     int request_id =
         version_->StartRequest(ServiceWorkerMetrics::EventType::INSTALL,
                                CreateReceiver(BrowserThread::UI, done, result));
     version_->DispatchSimpleEvent<ServiceWorkerHostMsg_ActivateEventFinished>(
         request_id, ServiceWorkerMsg_ActivateEvent(request_id));
   }
 
   void FetchOnIOThread(const base::Closure& done,
                        bool* prepare_result,
                        FetchResult* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
         embedded_test_server()->GetURL("/service_worker/empty.html"), "GET",
         ServiceWorkerHeaderMap(), Referrer(), false));
     version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
     fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
-        std::move(request), version_.get(),
+        std::move(request), version_.get(), RESOURCE_TYPE_MAIN_FRAME,
         CreatePrepareReceiver(prepare_result),
         CreateResponseReceiver(done, blob_context_.get(), result)));
     fetch_dispatcher_->Run();
   }
 
   // Contrary to the style guide, the output parameter of this function comes
   // before input parameters so Bind can be used on it to create a FetchCallback
   // to pass to DispatchFetchEvent.
   void ReceiveFetchResultOnIOThread(
       const base::Closure& quit,
@@ skipping 816 matching lines @@
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
   // Restart the worker.
   StartWorker(SERVICE_WORKER_OK);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
 }
 
 }  // namespace content