Fix filesystem API file_handlers to work for drive on ChromeOS.

webkit/fileapi/file_system_url.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/file_system_url.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 82 matching lines @@
     *type = file_system_type;
   if (file_path)
     *file_path = converted_path.NormalizePathSeparators().
         StripTrailingSeparators();
 
   return true;
 }
 
 FileSystemURL::FileSystemURL(const GURL& url)
     : type_(kFileSystemTypeUnknown),
-      mount_type_(kFileSystemTypeUnknown) {
+      mount_type_(kFileSystemTypeUnknown),
+      has_underlying_url_(false) {
   is_valid_ = ParseFileSystemSchemeURL(url, &origin_, &type_, &path_);
   virtual_path_ = path_;
   mount_type_ = type_;
 }
 
 FileSystemURL::FileSystemURL(const GURL& origin,
                              FileSystemType type,
                              const base::FilePath& path)
     : is_valid_(true),
       origin_(origin),
       type_(type),
       mount_type_(type),
       path_(path.NormalizePathSeparators()),
-      virtual_path_(path.NormalizePathSeparators()) {
+      virtual_path_(path.NormalizePathSeparators()),
+     has_underlying_url_(false) {
 }
 
 FileSystemURL::FileSystemURL(const GURL& origin,
                              FileSystemType mount_type,
                              const base::FilePath& virtual_path,
                              const std::string& filesystem_id,
                              FileSystemType cracked_type,
                              const base::FilePath& cracked_path)
     : is_valid_(true),
       origin_(origin),
       type_(cracked_type),
       mount_type_(mount_type),
       path_(cracked_path.NormalizePathSeparators()),
       filesystem_id_(filesystem_id),
-      virtual_path_(virtual_path.NormalizePathSeparators()) {
+      virtual_path_(virtual_path.NormalizePathSeparators()),
+      has_underlying_url_(false) {
 }
 
 FileSystemURL::~FileSystemURL() {}
 
+void FileSystemURL::SetUnderlyingURL(const FileSystemURL& underlying_url) {
+  has_underlying_url_ = true;
+  underlying_filesystem_id_ = underlying_url.filesystem_id();
+  underlying_type_ = underlying_url.type();
+  underlying_virtual_path_ = underlying_url.virtual_path();
+}
+
 std::string FileSystemURL::DebugString() const {
   if (!is_valid_)
     return "invalid filesystem: URL";
   std::ostringstream ss;
   ss << GetFileSystemRootURI(origin_, mount_type_);
 
   // filesystem_id_ will be non empty for (and only for) cracked URLs.
   if (!filesystem_id_.empty()) {
     ss << virtual_path_.value();
     ss << " (";
     ss << GetFileSystemTypeString(type_) << "@" << filesystem_id_ << ":";
     ss << path_.value();
     ss << ")";
   } else {
     ss << path_.value();
   }
   return ss.str();
 }
 
 bool FileSystemURL::IsParent(const FileSystemURL& child) const {
   return origin() == child.origin() &&
          type() == child.type() &&
          filesystem_id() == child.filesystem_id() &&
          path().IsParent(child.path());
 }
 
+FileSystemURL FileSystemURL::GetForOperations() const {
+  if (!has_underlying_url_)
+    return *this;
+  return FileSystemURL(origin_,
+                       mount_type_,
+                       underlying_virtual_path_,
+                       underlying_filesystem_id_,
+                       underlying_type_,
+                       path_);
+}
+
 bool FileSystemURL::operator==(const FileSystemURL& that) const {
   return origin_ == that.origin_ &&
       type_ == that.type_ &&
       path_ == that.path_ &&
       filesystem_id_ == that.filesystem_id_ &&
       is_valid_ == that.is_valid_;
 }
 
 bool FileSystemURL::Comparator::operator()(const FileSystemURL& lhs,
                                            const FileSystemURL& rhs) const {
   DCHECK(lhs.is_valid_ && rhs.is_valid_);
   if (lhs.origin_ != rhs.origin_)
     return lhs.origin_ < rhs.origin_;
   if (lhs.type_ != rhs.type_)
     return lhs.type_ < rhs.type_;
   if (lhs.filesystem_id_ != rhs.filesystem_id_)
     return lhs.filesystem_id_ < rhs.filesystem_id_;
   return lhs.path_ < rhs.path_;
 }
 
 }  // namespace fileapi