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"
 #include "net/base/escape.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 
 namespace fileapi {
 
 namespace {
 
 }  // namespace
 
 FileSystemURL::FileSystemURL()
     : is_valid_(false),
-      type_(kFileSystemTypeUnknown),
-      mount_type_(kFileSystemTypeUnknown) {
+      mount_type_(kFileSystemTypeUnknown),
+      type_(kFileSystemTypeUnknown) {
 }
 
 // static
 FileSystemURL FileSystemURL::CreateForTest(const GURL& url) {
   return FileSystemURL(url);
 }
 
 FileSystemURL FileSystemURL::CreateForTest(const GURL& origin,
                                            FileSystemType type,
                                            const base::FilePath& path) {
@@ skipping 55 matching lines @@
   if (type)
     *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),
+      type_(kFileSystemTypeUnknown) {
   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),
+      mount_type_(type),
+      virtual_path_(path.NormalizePathSeparators()),
       type_(type),
-      mount_type_(type),
-      path_(path.NormalizePathSeparators()),
-      virtual_path_(path.NormalizePathSeparators()) {
+      path_(path.NormalizePathSeparators()) {
 }
 
 FileSystemURL::FileSystemURL(const GURL& origin,
                              FileSystemType mount_type,
                              const base::FilePath& virtual_path,
-                             const std::string& filesystem_id,
+                             const std::string& mount_filesystem_id,
                              FileSystemType cracked_type,
-                             const base::FilePath& cracked_path)
+                             const base::FilePath& cracked_path,
+                             const std::string& filesystem_id)
     : is_valid_(true),
       origin_(origin),
+      mount_type_(mount_type),
+      virtual_path_(virtual_path.NormalizePathSeparators()),
+      mount_filesystem_id_(mount_filesystem_id),
       type_(cracked_type),
-      mount_type_(mount_type),
       path_(cracked_path.NormalizePathSeparators()),
-      filesystem_id_(filesystem_id),
-      virtual_path_(virtual_path.NormalizePathSeparators()) {
+      filesystem_id_(filesystem_id) {
 }
 
 FileSystemURL::~FileSystemURL() {}
 
 std::string FileSystemURL::DebugString() const {
   if (!is_valid_)
     return "invalid filesystem: URL";
   std::ostringstream ss;
   ss << GetFileSystemRootURI(origin_, mount_type_);
 
@@ skipping 31 matching lines @@
   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