Adding UMA stats for requestFileSystem error analysis.

webkit/fileapi/sandbox_mount_point_provider.cc

 // Copyright (c) 2011 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_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/metrics/histogram.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaManagerProxy;
 
 namespace {
 
 static const FilePath::CharType kOldFileSystemUniqueNamePrefix[] =
     FILE_PATH_LITERAL("chrome-");
 static const int kOldFileSystemUniqueLength = 16;
 static const unsigned kOldFileSystemUniqueDirectoryNameLength =
     kOldFileSystemUniqueLength + arraysize(kOldFileSystemUniqueNamePrefix) - 1;
 
+const char kOpenFileSystem[] = "FileSystem.OpenFileSystem";
+enum FileSystemError {
+  kOK = 0,
+  kIncognito,
+  kInvalidScheme,
+  kCreateDirectoryError,
+  kFileSystemErrorMax,
+};
+
 // Restricted names.
 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
 static const char* const kRestrictedNames[] = {
   ".", "..",
 };
 
 // Restricted chars.
 static const FilePath::CharType kRestrictedChars[] = {
   '/', '\\',
 };
@@ skipping 287 matching lines @@
  private:
   void GetFileSystemRootPathOnFileThread(bool create) {
     MigrateIfNeeded(file_util_, old_base_path_);
     DispatchCallbackOnCallerThread(
         file_util_->GetDirectoryForOriginAndType(origin_url_, type_, create));
     // We must clear the reference on the file thread.
     file_util_ = NULL;
   }
 
   void DispatchCallbackOnCallerThread(const FilePath& root_path) {
+    if (root_path.empty()) {
+      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
+                                kCreateDirectoryError,
+                                kFileSystemErrorMax);

[kinuko, 2011/12/15 04:34:05]

Tzik-san, I know this patch has been already landed but could we add slightly
more detailed metrics for this case?
GetDirectoryForOriginAndType could fail for various reasons and I suspect this
one would be the primary hot error spot.
(For example if it's failing due to CURRENT file corruption in origin db like
the one reported in 103018 the error must come from GetDirectoryForOrigin() =>
OriginDatabase::GetPathForOrigin() => OriginDatabase::Init().

+    }
     origin_message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&GetFileSystemRootPathTask::DispatchCallback, this,
                    root_path));
   }
 
   void DispatchCallback(const FilePath& root_path) {
     std::string origin_identifier = GetOriginIdentifierFromURL(origin_url_);
     std::string type_string =
         FileSystemPathManager::GetFileSystemTypeString(type_);
     DCHECK(!type_string.empty());
     std::string name = origin_identifier + ":" + type_string;
+
+    if (!root_path.empty())
+      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem, kOK, kFileSystemErrorMax);
+
     callback_.Run(!root_path.empty(), root_path, name);
     callback_.Reset();
   }
 
   scoped_refptr<base::MessageLoopProxy> file_message_loop_;
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   GURL origin_url_;
   FileSystemType type_;
   scoped_refptr<ObfuscatedFileUtil> file_util_;
   FilePath old_base_path_;
@@ skipping 50 matching lines @@
 }
 
 void SandboxMountPointProvider::ValidateFileSystemRootAndGetURL(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
     const FileSystemPathManager::GetRootPathCallback& callback) {
   FilePath origin_base_path;
 
   if (path_manager_->is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(false, FilePath(), std::string());
+    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
+                              kIncognito,
+                              kFileSystemErrorMax);
     return;
   }
 
   if (!path_manager_->IsAllowedScheme(origin_url)) {
     callback.Run(false, FilePath(), std::string());
+    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
+                              kInvalidScheme,
+                              kFileSystemErrorMax);
     return;
   }
 
   scoped_refptr<GetFileSystemRootPathTask> task(
       new GetFileSystemRootPathTask(
           file_message_loop_, origin_url, type, sandbox_file_util_.get(),
           old_base_path(), callback));
   task->Start(create);
 };
 
@@ skipping 204 matching lines @@
 
   // Creates the root directory.
   root = origin_base_path.Append(OldCreateUniqueDirectoryName(origin_url));
   if (!file_util::CreateDirectory(root))
     return FilePath();
 
   return root;
 }
 
 }  // namespace fileapi