Add UMA stats for ObfuscatedFileUtil::GetDirectoryForOriginAndTypes().

webkit/fileapi/obfuscated_file_util.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/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_util.h"
@@ skipping 802 matching lines @@
   if (!db->RemoveFileInfo(file_id))
     return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
   int64 growth = -UsageForPath(file_info.name.size());
   AllocateQuota(context, growth);
   UpdateUsage(context, virtual_path.origin(), virtual_path.type(), growth);
   TouchDirectory(db, file_info.parent_id);
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType(
-    const GURL& origin, FileSystemType type, bool create) {
-  FilePath origin_dir = GetDirectoryForOrigin(origin, create);
+    const GURL& origin,
+    FileSystemType type,
+    bool create,
+    base::PlatformFileError* error_code) {
+  FilePath origin_dir = GetDirectoryForOrigin(origin, create, error_code);
   if (origin_dir.empty())
     return FilePath();
   FilePath::StringType type_string = GetDirectoryNameForType(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
+
+    if (error_code)
+      *error_code = base::PLATFORM_FILE_ERROR_INVALID_URL;
     return FilePath();
   }
   FilePath path = origin_dir.Append(type_string);
   if (!file_util::DirectoryExists(path) &&
-      (!create || !file_util::CreateDirectory(path)))
+      (!create || !file_util::CreateDirectory(path))) {
+    if (error_code) {
+      *error_code = create ?
+          base::PLATFORM_FILE_ERROR_FAILED :
+          base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    }
     return FilePath();
+  }
+
+  if (error_code)
+    *error_code = base::PLATFORM_FILE_OK;
   return path;
 }
 
 bool ObfuscatedFileUtil::DeleteDirectoryForOriginAndType(
     const GURL& origin, FileSystemType type) {
   FilePath origin_type_path = GetDirectoryForOriginAndType(origin, type, false);
   if (!file_util::PathExists(origin_type_path))
     return true;
 
   // TODO(dmikurube): Consider the return value of DestroyDirectoryDatabase.
   // We ignore its error now since 1) it doesn't matter the final result, and
   // 2) it always returns false in Windows because of LevelDB's implementation.
   // Information about failure would be useful for debugging.
   DestroyDirectoryDatabase(origin, type);
   if (!file_util::Delete(origin_type_path, true /* recursive */))
     return false;
 
   FilePath origin_path = origin_type_path.DirName();
-  DCHECK_EQ(origin_path.value(), GetDirectoryForOrigin(origin, false).value());
+  DCHECK_EQ(origin_path.value(),
+            GetDirectoryForOrigin(origin, false, NULL).value());
 
   // Delete the origin directory if the deleted one was the last remaining
   // type for the origin.
   if (file_util::Delete(origin_path, false /* recursive */)) {
     InitOriginDatabase(false);
     if (origin_database_.get())
       origin_database_->RemovePathForOrigin(GetOriginIdentifierFromURL(origin));
   }
 
   // At this point we are sure we had successfully deleted the origin/type
@@ skipping 326 matching lines @@
       return NULL;
     }
   }
   MarkUsed();
   FileSystemDirectoryDatabase* database = new FileSystemDirectoryDatabase(path);
   directories_[key] = database;
   return database;
 }
 
 FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
-    const GURL& origin, bool create) {
-  if (!InitOriginDatabase(create))
+    const GURL& origin, bool create, base::PlatformFileError* error_code) {
+  if (!InitOriginDatabase(create)) {
+    if (error_code) {
+      *error_code = create ?
+          base::PLATFORM_FILE_ERROR_FAILED :
+          base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    }
     return FilePath();
+  }
   FilePath directory_name;
   std::string id = GetOriginIdentifierFromURL(origin);
 
   bool exists_in_db = origin_database_->HasOriginPath(id);
-  if (!exists_in_db && !create)
+  if (!exists_in_db && !create) {
+    if (error_code)
+      *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return FilePath();
-  if (!origin_database_->GetPathForOrigin(id, &directory_name))
+  }
+  if (!origin_database_->GetPathForOrigin(id, &directory_name)) {
+    if (error_code)
+      *error_code = base::PLATFORM_FILE_ERROR_FAILED;
     return FilePath();
+  }
 
   FilePath path = file_system_directory_.Append(directory_name);
   bool exists_in_fs = file_util::DirectoryExists(path);
   if (!exists_in_db && exists_in_fs) {
-    if (!file_util::Delete(path, true))
+    if (!file_util::Delete(path, true)) {
+      if (error_code)
+        *error_code = base::PLATFORM_FILE_ERROR_FAILED;
       return FilePath();
+    }
     exists_in_fs = false;
   }
 
   if (!exists_in_fs) {
-    if (!create || !file_util::CreateDirectory(path))
+    if (!create || !file_util::CreateDirectory(path)) {
+      if (error_code)
+        *error_code = create ?
+            base::PLATFORM_FILE_ERROR_FAILED :
+            base::PLATFORM_FILE_ERROR_NOT_FOUND;
       return FilePath();
+    }
   }
 
+  if (error_code)
+    *error_code = base::PLATFORM_FILE_OK;
+
   return path;
 }
 
 void ObfuscatedFileUtil::MarkUsed() {
   if (timer_.IsRunning())
     timer_.Reset();
   else
     timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(kFlushDelaySeconds),
                  this, &ObfuscatedFileUtil::DropDatabases);
 }
@@ skipping 14 matching lines @@
           file_system_directory_.value();
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(file_system_directory_));
   }
   return true;
 }
 
 }  // namespace fileapi