Use chromium logic for database identifier<->origin conversions

webkit/browser/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/browser/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/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
-#include "webkit/base/origin_url_conversions.h"
 #include "webkit/browser/fileapi/file_observers.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/browser/fileapi/timed_task_helper.h"
 #include "webkit/browser/quota/quota_manager.h"
+#include "webkit/common/database/database_identifier.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 // Example of various paths:
 //   void ObfuscatedFileUtil::DoSomething(const FileSystemURL& url) {
 //     base::FilePath virtual_path = url.path();
 //     base::FilePath local_path = GetLocalFilePath(url);
 //
 //     NativeFileUtil::DoSomething(local_path);
 //     file_util::DoAnother(local_path);
 //  }
@@ skipping 178 matching lines @@
   virtual ~ObfuscatedOriginEnumerator() {}
 
   // Returns the next origin.  Returns empty if there are no more origins.
   virtual GURL Next() OVERRIDE {
     OriginRecord record;
     if (!origins_.empty()) {
       record = origins_.back();
       origins_.pop_back();
     }
     current_ = record;
-    return webkit_base::GetOriginURLFromIdentifier(record.origin);
+    return webkit_database::GetOriginFromIdentifier(record.origin);
   }
 
   // Returns the current origin's information.
   virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
     if (current_.path.empty())
       return false;
     base::FilePath::StringType type_string =
         ObfuscatedFileUtil::GetDirectoryNameForType(type);
     if (type_string.empty()) {
       NOTREACHED();
@@ skipping 683 matching lines @@
             origin_path.Append(GetDirectoryNameForType(other_types[i])))) {
       // Other type's directory exists; just return true here.
       return true;
     }
   }
 
   // No other directories seem exist. Try deleting the entire origin directory.
   InitOriginDatabase(false);
   if (origin_database_) {
     origin_database_->RemovePathForOrigin(
-        webkit_base::GetOriginIdentifierFromURL(origin));
+        webkit_database::GetIdentifierFromOrigin(origin));
   }
   if (!file_util::Delete(origin_path, true /* recursive */))
     return false;
 
   return true;
 }
 
 // static
 base::FilePath::StringType ObfuscatedFileUtil::GetDirectoryNameForType(
     FileSystemType type) {
@@ skipping 21 matching lines @@
 }
 
 bool ObfuscatedFileUtil::DestroyDirectoryDatabase(
     const GURL& origin, FileSystemType type) {
   std::string type_string = GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return true;
   }
   std::string key =
-      webkit_base::GetOriginIdentifierFromURL(origin) +
+      webkit_database::GetIdentifierFromOrigin(origin) +
       type_string;
   DirectoryMap::iterator iter = directories_.find(key);
   if (iter != directories_.end()) {
     SandboxDirectoryDatabase* database = iter->second;
     directories_.erase(iter);
     delete database;
   }
 
   PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath path = GetDirectoryForOriginAndType(
@@ skipping 184 matching lines @@
   std::string type_string = GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return std::string();
   }
   // For isolated origin we just use a type string as a key.
   if (special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin)) {
     return type_string;
   }
-  return webkit_base::GetOriginIdentifierFromURL(origin) +
+  return webkit_database::GetIdentifierFromOrigin(origin) +
       type_string;
 }
 
 // TODO(ericu): How to do the whole validation-without-creation thing?
 // We may not have quota even to create the database.
 // Ah, in that case don't even get here?
 // Still doesn't answer the quota issue, though.
 SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     const GURL& origin, FileSystemType type, bool create) {
   std::string key = GetDirectoryDatabaseKey(origin, type);
@@ skipping 31 matching lines @@
 
   if (!InitOriginDatabase(create)) {
     if (error_code) {
       *error_code = create ?
           base::PLATFORM_FILE_ERROR_FAILED :
           base::PLATFORM_FILE_ERROR_NOT_FOUND;
     }
     return base::FilePath();
   }
   base::FilePath directory_name;
-  std::string id = webkit_base::GetOriginIdentifierFromURL(origin);
+  std::string id = webkit_database::GetIdentifierFromOrigin(origin);
 
   bool exists_in_db = origin_database_->HasOriginPath(id);
   if (!exists_in_db && !create) {
     if (error_code)
       *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return base::FilePath();
   }
   if (!origin_database_->GetPathForOrigin(id, &directory_name)) {
     if (error_code)
       *error_code = base::PLATFORM_FILE_ERROR_FAILED;
@@ skipping 66 matching lines @@
   if (!file_util::CreateDirectory(file_system_directory_)) {
     LOG(WARNING) << "Failed to create FileSystem directory: " <<
         file_system_directory_.value();
     return false;
   }
 
   if (!isolated_origin_.is_empty()) {
     DCHECK(special_storage_policy_->HasIsolatedStorage(isolated_origin_));
     origin_database_.reset(
         new SandboxIsolatedOriginDatabase(
-            webkit_base::GetOriginIdentifierFromURL(isolated_origin_),
+            webkit_database::GetIdentifierFromOrigin(isolated_origin_),
             file_system_directory_));
     return true;
   }
 
   origin_database_.reset(
       new SandboxOriginDatabase(file_system_directory_));
   return true;
 }
 
 PlatformFileError ObfuscatedFileUtil::GenerateNewLocalPath(
@@ skipping 104 matching lines @@
   // If truncating we need to update the usage.
   if (error == base::PLATFORM_FILE_OK && delta) {
     UpdateUsage(context, url, delta);
     context->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
   }
   return error;
 }
 
 }  // namespace fileapi