Add UMA stats for ObfuscatedFileUtil::GetDirectoryForOriginAndTypes().

webkit/fileapi/sandbox_mount_point_provider.cc

 // Copyright (c) 2012 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 "webkit/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 25 matching lines @@
 const char kChromeScheme[] = "chrome";
 const char kExtensionScheme[] = "chrome-extension";
 
 const FilePath::CharType kOldFileSystemUniqueNamePrefix[] =
     FILE_PATH_LITERAL("chrome-");
 const size_t kOldFileSystemUniqueLength = 16;
 const size_t kOldFileSystemUniqueDirectoryNameLength =
     kOldFileSystemUniqueLength + arraysize(kOldFileSystemUniqueNamePrefix) - 1;
 
 const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
+const char kOpenFileSystemBreakLabel[] = "FileSystem.OpenFileSystemBreak";

[kinuko, 2012/05/08 06:29:17]

Break -> Detail?
Unique -> NonThrottled?

[tzik, 2012/05/08 06:39:24]

Done.

+const char kOpenFileSystemUniqueBreakLabel[] =
+    "FileSystem.OpenFileSystemUnqueBreak";
+int64 kMinimumStatsCollectionIntervalHours = 1;
+
 enum FileSystemError {
   kOK = 0,
   kIncognito,
-  kInvalidScheme,
+  kInvalidSchemeError,
   kCreateDirectoryError,
+  kNotFound,
+  kUnknownError,
   kFileSystemErrorMax,
 };
 
 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
 
 // Restricted names.
 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
 const FilePath::CharType* const kRestrictedNames[] = {
   FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
@@ skipping 199 matching lines @@
     MigrateAllOldFileSystems(file_util, old_base_path);
 }
 
 void PassPointerErrorByValue(
     const base::Callback<void(PlatformFileError)>& callback,
     PlatformFileError* error_ptr) {
   DCHECK(error_ptr);
   callback.Run(*error_ptr);
 }
 
-void ValidateRootOnFileThread(ObfuscatedFileUtil* file_util,
-                              const GURL& origin_url,
-                              FileSystemType type,
-                              const FilePath& old_base_path,
-                              bool create,
-                              base::PlatformFileError* error_ptr) {
+void DidValidateFileSystemRoot(
+    base::WeakPtr<SandboxMountPointProvider> mount_point_provider,
+    const base::Callback<void(PlatformFileError)>& callback,
+    base::PlatformFileError* error) {
+  if (mount_point_provider.get())
+    mount_point_provider.get()->CollectOpenFileSystemMetrics(*error);
+  callback.Run(*error);
+}
+
+void ValidateRootOnFileThread(
+    ObfuscatedFileUtil* file_util,
+    const GURL& origin_url,
+    FileSystemType type,
+    const FilePath& old_base_path,
+    bool create,
+    base::PlatformFileError* error_ptr) {
   DCHECK(error_ptr);
   MigrateIfNeeded(file_util, old_base_path);
+
   FilePath root_path =
-      file_util->GetDirectoryForOriginAndType(origin_url, type, create);
+      file_util->GetDirectoryForOriginAndType(
+          origin_url, type, create, error_ptr);
   if (root_path.empty()) {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kCreateDirectoryError,
                               kFileSystemErrorMax);
-    // TODO(kinuko): We should return appropriate error code.
-    *error_ptr = base::PLATFORM_FILE_ERROR_FAILED;
   } else {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
-    *error_ptr = base::PLATFORM_FILE_OK;
   }
   // The reference of file_util will be derefed on the FILE thread
   // when the storage of this callback gets deleted regardless of whether
   // this method is called or not.
 }
 
 }  // anonymous namespace
 
 const FilePath::CharType SandboxMountPointProvider::kOldFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
         FILE_PATH_LITERAL("FS.old");
 
 SandboxMountPointProvider::SandboxMountPointProvider(
     base::SequencedTaskRunner* file_task_runner,
     const FilePath& profile_path,
     const FileSystemOptions& file_system_options)
     : FileSystemQuotaUtil(file_task_runner),
       file_task_runner_(file_task_runner),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       sandbox_file_util_(
           new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
-              QuotaFileUtil::CreateDefault())) {
+              QuotaFileUtil::CreateDefault())),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
     ObfuscatedFileUtil* sandbox_file_util = sandbox_file_util_.release();
     if (!file_task_runner_->ReleaseSoon(FROM_HERE, sandbox_file_util))
       sandbox_file_util->Release();
   }
 }
 
 void SandboxMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
     const ValidateFileSystemCallback& callback) {
   if (file_system_options_.is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
-                              kInvalidScheme,
+                              kInvalidSchemeError,
                               kFileSystemErrorMax);
     return;
   }
 
   base::PlatformFileError* error_ptr = new base::PlatformFileError;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ValidateRootOnFileThread,
                  sandbox_file_util_,
                  origin_url, type, old_base_path(), create,
                  base::Unretained(error_ptr)),
-      base::Bind(base::Bind(&PassPointerErrorByValue, callback),
-                 base::Owned(error_ptr)));
+      base::Bind(&DidValidateFileSystemRoot,
+                 weak_factory_.GetWeakPtr(),
+                 callback, base::Owned(error_ptr)));
 };
 
 FilePath
 SandboxMountPointProvider::GetFileSystemRootPathOnFileThread(
     const GURL& origin_url, FileSystemType type, const FilePath& unused,
     bool create) {
   if (file_system_options_.is_incognito())
     // TODO(kinuko): return an isolated temporary directory.
     return FilePath();
 
@@ skipping 298 matching lines @@
   for (size_t i = 0;
        i < file_system_options_.additional_allowed_schemes().size();
        ++i) {
     if (url.SchemeIs(
             file_system_options_.additional_allowed_schemes()[i].c_str()))
       return true;
   }
   return false;
 }
 
+void SandboxMountPointProvider::CollectOpenFileSystemMetrics(
+    base::PlatformFileError error_code) {
+  base::Time now = base::Time::Now();
+  bool throttled = now < next_release_time_for_open_filesystem_stat_;
+  if (!throttled) {
+    next_release_time_for_open_filesystem_stat_ =
+        now + base::TimeDelta::FromHours(kMinimumStatsCollectionIntervalHours);
+  }
+
+#define REPORT(report_value)                                    \
+  UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemBreakLabel,          \
+                            (report_value),                     \
+                            kFileSystemErrorMax);               \
+  if (!throttled) {                                             \
+    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemUniqueBreakLabel,  \
+                              (report_value),                   \
+                              kFileSystemErrorMax);             \
+  }
+
+  switch (error_code) {
+    case base::PLATFORM_FILE_OK:
+      REPORT(kOK);
+      break;
+    case base::PLATFORM_FILE_ERROR_INVALID_URL:
+      REPORT(kInvalidSchemeError);
+      break;
+    case base::PLATFORM_FILE_ERROR_NOT_FOUND:
+      REPORT(kNotFound);
+      break;
+    case base::PLATFORM_FILE_ERROR_FAILED:
+    default:
+      REPORT(kUnknownError);
+      break;
+  }
+#undef REPORT
+}
+
 }  // namespace fileapi