Add initial code to do filename munging in the FileSystem....

webkit/fileapi/obfuscated_name_map.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/obfuscated_name_map.h"
+
+#if defined(OS_WIN)
+#include <errno.h>
+#endif
+
+#include "base/file_util.h"
+#include "base/format_macros.h"
+#include "base/logging.h"
+#include "base/stringprintf.h"
+
+namespace obfuscated_file_util {
+
+ObfuscatedNameMap::ObfuscatedNameMap()
+  : directory_()
+  , map_valid_(false)
+  , map_next_valid_(false) {

[michaeln, 2011/02/11 00:03:34]

Massage the style here to chrome-land style :) Or have we adopted this style for
init lists too?

[ericu, 2011/02/11 01:57:47]

No, that's an accidental webkit-style leak.

+}
+
+void ObfuscatedNameMap::Init(const FilePath& directory) {
+  RollBack();
+  map_valid_ = false;
+  map_.clear();
+  map_next_valid_ = false;
+  map_next_.clear();
+  directory_ = directory;
+}
+
+PlatformFileError ObfuscatedNameMap::ClearNameFromObfuscatedName(
+    StringType obfuscated_name,
+    StringType* clear_name) {
+  CHECK(clear_name);
+  {

[michaeln, 2011/02/11 00:03:34]

is the extra scope here intentional?

[ericu, 2011/02/11 01:57:47]

It was just to limit the scope of error, but that seems a bit heavy-handed now. 
I think that came from an earlier attempt that was more complicated.  I'll take
it out.

+    PlatformFileError error = LoadFromFile();
+    if (base::PLATFORM_FILE_OK != error)
+      return error;
+  }
+  MapType::iterator found = map_.find(obfuscated_name);
+  if (found == map_.end())
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  *clear_name = found->second;
+  return base::PLATFORM_FILE_OK;
+}
+
+StringType ObfuscatedNameMap::ObfuscatedNameFromClearName(
+    StringType clear_name) {
+  // FIXME: This is a hack to get around the fact that PRIxS produces an 8-bit
+  // string on all platforms, and the macro that would fix that gets evaluated
+  // *before* PRIxS does, so it can't be used.
+  FilePath temp;
+  return base::StringPrintf(
+      temp.AppendASCII("%08" PRIxS).BaseName().value().c_str(),
+      hash(FilePath(clear_name)));
+}
+
+PlatformFileError ObfuscatedNameMap::PrepareAdd(
+    const StringType& clear_name, const StringType& obfuscated_name) {
+  PlatformFileError error = InitDictNext();
+  if (base::PLATFORM_FILE_OK != error)
+    return error;
+#ifndef NDEBUG
+  StringType test_name(ObfuscatedNameFromClearName(clear_name));
+  CHECK(test_name == obfuscated_name);
+#endif
+  if (map_next_.find(obfuscated_name) != map_next_.end())
+    return base::PLATFORM_FILE_ERROR_EXISTS;
+  map_next_[obfuscated_name] = clear_name;
+  return WriteToNextFile();
+}
+
+PlatformFileError ObfuscatedNameMap::PrepareDelete(
+    const StringType& clear_name, const StringType& obfuscated_name) {
+  PlatformFileError error = InitDictNext();
+  if (base::PLATFORM_FILE_OK != error)
+    return error;
+#ifndef NDEBUG
+  StringType test_name(ObfuscatedNameFromClearName(clear_name));
+  CHECK(test_name == obfuscated_name);
+#endif
+
+  MapType::iterator found = map_next_.find(obfuscated_name);
+  if (found == map_next_.end())
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  map_next_.erase(found);
+  return WriteToNextFile();
+}
+
+PlatformFileError ObfuscatedNameMap::PrepareMove(
+    const StringType& old_clear_name,
+    const StringType& old_obfuscated_name,
+    const StringType& new_clear_name,
+    const StringType& new_obfuscated_name) {
+  PlatformFileError error = InitDictNext();
+  if (base::PLATFORM_FILE_OK != error)
+    return error;
+#ifndef NDEBUG
+  StringType test_name(ObfuscatedNameFromClearName(old_clear_name));
+  CHECK(test_name == old_obfuscated_name);
+  test_name = ObfuscatedNameFromClearName(new_clear_name);
+  CHECK(test_name == new_obfuscated_name);
+#endif
+  if (map_next_.find(new_obfuscated_name) != map_next_.end())
+    return base::PLATFORM_FILE_ERROR_EXISTS;
+  MapType::iterator old_found = map_next_.find(old_obfuscated_name);
+  if (old_found == map_next_.end())
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  map_next_.erase(old_found);
+  map_next_[new_obfuscated_name] = new_clear_name;
+  return WriteToNextFile();
+}
+
+PlatformFileError ObfuscatedNameMap::Commit() {
+  CHECK(map_next_valid_);
+  if (file_util::Move(GetDictionaryNextLocation(), GetDictionaryLocation())) {
+    map_ = map_next_;

[michaeln, 2011/02/11 00:03:34]

i wonder if you can use the swap method here?
  map_.clear();
  map_.swap(map_next_);

[ericu, 2011/02/11 01:57:47]

Yup.

+    map_valid_ = map_next_valid_;
+    map_next_valid_ = false;
+    map_next_.clear();
+    return base::PLATFORM_FILE_OK;
+  } else {
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  }
+}
+
+void ObfuscatedNameMap::RollBack() {
+  if (map_next_valid_) {
+    map_next_valid_ = false;
+    map_next_.clear();
+    // The file may or may not exist; we delete it and ignore errors.
+    file_util::Delete(GetDictionaryNextLocation(), false);
+  }
+}
+
+size_t ObfuscatedNameMap::hash(const FilePath& f) {
+  // TODO(ericu): This is temporary--find a real SHA1 implementation or the
+  // like somewhere in our existing codebase.
+#if defined(COMPILER_GCC)
+  struct __gnu__cxx::hash<FilePath> gcc_hash;
+  return gcc_hash(f);
+#elif defined(COMPILER_MSVC)
+  return stdext::hash_value(f);
+#else
+#error  // Must define hashing function
+#endif
+}
+
+FilePath ObfuscatedNameMap::GetDictionaryLocation() {
+  return directory_.Append(FilePath(DICTIONARY_NAME));
+}
+
+FilePath ObfuscatedNameMap::GetDictionaryNextLocation() {
+  return directory_.Append(FilePath(DICTIONARY_NEXT_NAME));
+}
+
+PlatformFileError ObfuscatedNameMap::LoadFromFile() {

[michaeln, 2011/02/11 00:03:34]

maybe rename the method to make it more clear that if the file is already
loaded, this is a noop... LazyLoadFromFile()?

[ericu, 2011/02/11 01:57:47]

Will do.

+  if (map_valid_)
+    return base::PLATFORM_FILE_OK;
+
+  PlatformFileError error = RecoverIfNeeded();
+  if (base::PLATFORM_FILE_OK != error)
+    return error;
+
+  if (!file_util::PathExists(GetDictionaryLocation())) {
+    map_valid_ = true; // It's just empty.
+    return base::PLATFORM_FILE_OK;
+  }
+
+  std::string contents;
+  if (!file_util::ReadFileToString(GetDictionaryLocation(), &contents))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  StringType data;
+#if defined(OS_POSIX)
+  data = contents;
+#elif defined(OS_WIN)
+  errno_t local_errno;
+  size_t size = 0;
+
+  local_errno = mbstowcs_s(&size, NULL, 0, contents.c_str(), 0);
+  // FIXME: If either of these two happen, the dictionary is corrupt or
+  // otherwise unusable.  We should probably log an error and continue, but I
+  // won't do that yet.
+  // Max entries + entry length + a little padding.
+  if (local_errno || size > 4000 * (256 + 120))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  scoped_ptr<wchar_t> buffer(new wchar_t[size]);
+  local_errno =
+      mbstowcs_s(&size, buffer.get(), size, contents.c_str(), size - 1);
+  if (local_errno) {
+    return base::PLATFORM_FILE_ERROR_FAILED;  // This should never happen.
+  }
+  data = buffer.get();
+#else
+#error  // Must define the appropriate conversion here.
+#endif
+  LoadMapFromString(&map_, data);
+  return base::PLATFORM_FILE_OK;
+}
+
+void ObfuscatedNameMap::LoadMapFromString(
+    MapType* map, const StringType& serialized) {
+  // Format: ([a-z0-0]+:[$legal_set_of_filename_chars]+:\n)*
+  // Empty is legal; it's easier than deleting the dict when we remove the
+  // last file from the dir, probably?
+  // Note that ':' is the separator *and* the terminator [along with the
+  // newline], since a newline could legally be in the filename.
+  StringType hash, name;
+  MapType temp_map;
+  size_t i;
+  for (i = 0; i < serialized.length(); ++i) {
+    size_t hash_start = i;
+    i = serialized.find(SEPARATOR, i);
+    if (i == StringType::npos)
+      break;
+    size_t hash_end = i;
+    size_t name_start = i + SEPARATOR.length();
+    size_t name_end = serialized.find(TERMINATOR, name_start);
+    if (name_end == StringType::npos)
+      break;  // TODO(ericu): Log an error here, but continue?
+    i = name_end + TERMINATOR.length();
+    hash = serialized.substr(hash_start, hash_end - hash_start);
+    name = serialized.substr(name_start, name_end - name_start);
+    temp_map[hash] = name;
+  }
+//    if (i != serialized.length())
+//      ;  // TODO(ericu): Log an error here, but continue?
+  map->swap(temp_map);
+}
+
+StringType ObfuscatedNameMap::ConvertMapToString(const MapType& map) {
+  StringType serialized;
+  for (MapType::const_iterator iter = map.begin();
+      iter != map.end(); ++iter) {
+    serialized += iter->first + SEPARATOR + iter->second + TERMINATOR;
+  }
+  return serialized;
+}
+
+PlatformFileError ObfuscatedNameMap::InitDictNext() {

[michaeln, 2011/02/11 00:03:34]

InitNextMap()? This is the only place the term 'dict' shows up in this class
although i see that term is used elsewhere in the CL.

[ericu, 2011/02/11 01:57:47]

I'll try to clean up the map vs. dict terminology.  Maybe I should just drop
dict entirely, but I liked having it refer to the on-disk dictionary, vs. the
in-memory map.  This method isn't named properly anyway, though.

+  CHECK(!map_next_valid_);
+  if (!map_valid_) {

[michaeln, 2011/02/11 00:03:34]

Given how LoadFromFile works, i don't think you need to test map_valid_ here.
(maybe that's where the extra scope above came from :)

[ericu, 2011/02/11 01:57:47]

You mean just always call it, since it's lazy?  Yeah, that works.

+    PlatformFileError error = LoadFromFile();
+    if (base::PLATFORM_FILE_OK != error)
+      return error;
+  }
+  map_next_ = map_;
+  map_next_valid_ = true;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError ObfuscatedNameMap::RecoverIfNeeded() {
+  // TODO(ericu): if DICT_NEXT doesn't exist, return base::PLATFORM_FILE_OK.
+  // TODO(ericu): read map_ from DICT, map_next from DICT_NEXT.
+  // TODO(ericu): find the *one* element that differs.
+  // TODO(ericu): if it's not exactly one, goto handle_error
+  // TODO(ericu):
+  //   if it's a deletion:
+  //     if the file's gone, commit the dict, else revert the dict
+  //   else if it's an addition:
+  //     if the file's there, commit the dict, else revert the dict
+  //   else // it's a move:
+  //     if the old file's gone and the new file's there, commit the dict.
+  //     if the old file's there and the new file's not, revert the dict.
+  //     else goto handle_error
+  //   return base::PLATFORM_FILE_OK;
+  //   handle_error: either return an error here, or revert the dict so that
+  //                 progress can be made; it's a policy decision.
+  //                 either way, make sure that map_valid_ is valid.
+  //
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError ObfuscatedNameMap::WriteToNextFile() {
+  StringType contents = ConvertMapToString(map_next_);
+  std::string data;
+#if defined(OS_POSIX)
+  data = contents;

[michaeln, 2011/02/11 00:03:34]

another potential swap() callsite?

[ericu, 2011/02/11 01:57:47]

Yup.

+#elif defined(OS_WIN)
+  static const size_t BUFFER_SIZE = 1024;
+  char buffer[BUFFER_SIZE];
+  errno_t error;
+  size_t offset = 0;
+  size_t converted;
+
+  while (offset < contents.length()) {
+    error = wcstombs_s(&converted, buffer, BUFFER_SIZE, contents.c_str() +

[michaeln, 2011/02/11 00:03:34]

is there's no util that can do this conversion for you? would it make any sense
to put this somewhere in 'base' as a utility in case this particular conversion
is needed elsewhere?

also, some comments about these char set conversions would be helpful.

[ericu, 2011/02/11 01:57:47]

I'm not sure that base is the place, given that I'm converting from StringType,
which is a FilePath thing.  Possibly in FilePath, though?  Hmm...actually, this
only works because I know that StringType is a Windows wstring, so I guess it
could go in base with that signature.
Will add some.

+        offset, _TRUNCATE);
+    if (error && error != STRUNCATE) {
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+    offset += converted;
+    data += buffer;
+  }
+  CHECK_EQ(contents.length(), data.length());
+#else
+#error  // Must define the appropriate conversion here.
+#endif
+  size_t bytes_written = 0;
+  FilePath location = GetDictionaryNextLocation();
+  while (bytes_written < data.length()) {
+    int write_response = file_util::WriteFile(
+        location, data.c_str() + bytes_written, data.length());
+    if (write_response <= 0) {
+      if (bytes_written)
+        file_util::Delete(GetDictionaryNextLocation(), false /* recursive */);
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+    bytes_written += write_response;
+  }
+  return base::PLATFORM_FILE_OK;
+}
+
+const StringType ObfuscatedNameMap::DICTIONARY_NAME =

[michaeln, 2011/02/11 00:03:34]

Since StringType is a class with a constructor, i don't think we want these as
globals. I think we have to construct/init these lazily.

[ericu, 2011/02/11 01:57:47]

Good point.  Converted to StringType::value_type.

+    FILE_PATH_LITERAL("dict");
+const StringType ObfuscatedNameMap::DICTIONARY_NEXT_NAME =
+    FILE_PATH_LITERAL("dict_next");
+const StringType ObfuscatedNameMap::SEPARATOR =
+    FILE_PATH_LITERAL(":");
+const StringType ObfuscatedNameMap::TERMINATOR =
+    FILE_PATH_LITERAL(":\n");
+
+}  // namespace obfuscated_file_util