[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.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",

[michaeln, 2015/03/13 22:47:16]

Should the label be "CreateCacheResult"?

[jkarlin, 2015/03/14 01:47:19]

The names are a bit misleading. ServiceWorkerCache::Init creates the actual
SimpleCache backend, and we have UMA there. 

This is for ServiceWorkerCacheStorage::SimpleCacheLoader (as opposed to
MemoryLoader), which preps the directory and write's the cache's name to an
index file. That's what this histogram is for.

+                        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) {

[michaeln, 2015/03/13 22:47:16]

unrelated but why is 'success' not important here?

[jkarlin, 2015/03/14 01:47:19]

Eek. Added a todo.

   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache.get());
 
   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();
@@ skipping 69 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