[ServiceWorkerCache] Cache and CacheStorage creation UMA

content/browser/service_worker/service_worker_cache_storage.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_cache_storage.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/ref_counted.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/browser/service_worker/service_worker_cache_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
@@ skipping 583 matching lines @@
     const CacheAndErrorCallback& callback,
     const scoped_refptr<ServiceWorkerCache>& cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache.get()) {
     callback.Run(scoped_refptr<ServiceWorkerCache>(),
                  CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
+  UMA_HISTOGRAM_BOOLEAN("ServiceWorkerCache.CreateCacheStorageResult",
+                        cache != nullptr);
+
   cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
   ordered_cache_names_.push_back(cache_name);
 
   cache_loader_->WriteIndex(
       ordered_cache_names_,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  cache));
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     const scoped_refptr<ServiceWorkerCache>& cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache.get());
 
+  // TODO(jkarlin): Handle !success.
+
   callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::HasCacheImpl(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback) {
   bool has_cache = cache_map_.find(cache_name) != cache_map_.end();
 
   callback.Run(has_cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
@@ skipping 66 matching lines @@
   callback.Run(ordered_cache_names_, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::MatchCacheImpl(
     const std::string& cache_name,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback) {
   scoped_refptr<ServiceWorkerCache> cache = GetLoadedCache(cache_name);
 
   if (!cache.get()) {
-    callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
+    callback.Run(ServiceWorkerCache::ERROR_TYPE_NOT_FOUND,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // Pass the cache along to the callback to keep the cache open until match is
   // done.
   cache->Match(request.Pass(),
                base::Bind(&ServiceWorkerCacheStorage::MatchCacheDidMatch,
                           weak_factory_.GetWeakPtr(), cache, callback));
@@ skipping 32 matching lines @@
   }
 }
 
 void ServiceWorkerCacheStorage::MatchAllCachesDidMatch(
     scoped_refptr<ServiceWorkerCache> cache,
     const base::Closure& barrier_closure,
     ServiceWorkerCache::ResponseCallback* callback,
     ServiceWorkerCache::ErrorType error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> handle) {
-  if (callback->is_null() || error == ServiceWorkerCache::ErrorTypeNotFound) {
+  if (callback->is_null() ||
+      error == ServiceWorkerCache::ERROR_TYPE_NOT_FOUND) {
     barrier_closure.Run();
     return;
   }
   callback->Run(error, response.Pass(), handle.Pass());
   callback->Reset();  // Only call the callback once.
 
   barrier_closure.Run();
 }
 
 void ServiceWorkerCacheStorage::MatchAllCachesDidMatchAll(
     scoped_ptr<ServiceWorkerCache::ResponseCallback> callback) {
   if (!callback->is_null()) {
-    callback->Run(ServiceWorkerCache::ErrorTypeNotFound,
+    callback->Run(ServiceWorkerCache::ERROR_TYPE_NOT_FOUND,
                   scoped_ptr<ServiceWorkerResponse>(),
                   scoped_ptr<storage::BlobDataHandle>());
   }
 }
 
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCacheStorage::GetLoadedCache(
     const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
@@ skipping 94 matching lines @@
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
   base::WeakPtr<ServiceWorkerCacheStorage> cache_storage =
       weak_factory_.GetWeakPtr();
 
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content