Move Mime type handling to streamsPrivate API, so that it works on Desktop Chrome.

chrome/browser/chromeos/extensions/file_browser_handler.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 "chrome/browser/chromeos/extensions/file_browser_handler.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 25 matching lines @@
 unsigned int GetAccessPermissionFlagFromString(const std::string& access_str) {
   if (access_str == kReadAccessString)
     return kReadPermission;
   if (access_str == kReadWriteAccessString)
     return kReadPermission | kWritePermission;
   if (access_str == kCreateAccessString)
     return kCreatePermission;
   return kInvalidPermission;
 }
 
-const char* const kMIMETypeHandlersWhitelist[] = {
-  extension_misc::kQuickOfficeExtensionId,
-  extension_misc::kQuickOfficeDevExtensionId
-};
-
 // Stored on the Extension.
 struct FileBrowserHandlerInfo : public extensions::Extension::ManifestData {
   FileBrowserHandler::List file_browser_handlers;
 
   FileBrowserHandlerInfo();
   virtual ~FileBrowserHandlerInfo();
 };
 
 FileBrowserHandlerInfo::FileBrowserHandlerInfo() {
 }
 
 FileBrowserHandlerInfo::~FileBrowserHandlerInfo() {
 }
 
 }  // namespace
 
-// static
-bool FileBrowserHandler::ExtensionWhitelistedForMIMETypes(
-    const std::string& extension_id) {
-  if (g_test_extension_id_ && extension_id == *g_test_extension_id_)
-    return true;
-  for (size_t i = 0; i < arraysize(kMIMETypeHandlersWhitelist); ++i) {
-    if (extension_id == kMIMETypeHandlersWhitelist[i])
-      return true;
-  }
-  return false;
-}
-
-// static
-std::vector<std::string> FileBrowserHandler::GetMIMETypeWhitelist() {
-  std::vector<std::string> whitelist;
-  if (g_test_extension_id_)
-    whitelist.push_back(*g_test_extension_id_);
-  for (size_t i = 0; i < arraysize(kMIMETypeHandlersWhitelist); ++i)
-    whitelist.push_back(kMIMETypeHandlersWhitelist[i]);
-  return whitelist;
-}
-
 FileBrowserHandler::FileBrowserHandler()
     : file_access_permission_flags_(kPermissionsNotDefined) {
 }
 
 FileBrowserHandler::~FileBrowserHandler() {
 }
 
 void FileBrowserHandler::AddPattern(const URLPattern& pattern) {
   url_set_.AddPattern(pattern);
 }
 
 void FileBrowserHandler::ClearPatterns() {
   url_set_.ClearPatterns();
 }
 
 bool FileBrowserHandler::MatchesURL(const GURL& url) const {
   return url_set_.MatchesURL(url);
 }
 
-void FileBrowserHandler::AddMIMEType(const std::string& mime_type) {
-  DCHECK(ExtensionWhitelistedForMIMETypes(extension_id()));
-  mime_type_set_.insert(mime_type);
-}
-
-bool FileBrowserHandler::CanHandleMIMEType(const std::string& mime_type) const {
-  return mime_type_set_.find(mime_type) != mime_type_set_.end();
-}
-
 bool FileBrowserHandler::AddFileAccessPermission(
     const std::string& access) {
   file_access_permission_flags_ |= GetAccessPermissionFlagFromString(access);
   return (file_access_permission_flags_ & kInvalidPermission) != 0U;
 }
 
 bool FileBrowserHandler::ValidateFileAccessPermissions() {
   bool is_invalid = (file_access_permission_flags_ & kInvalidPermission) != 0U;
   bool can_create = (file_access_permission_flags_ & kCreatePermission) != 0U;
   bool can_read_or_write = (file_access_permission_flags_ &
@@ skipping 26 matching lines @@
 // static
 FileBrowserHandler::List*
 FileBrowserHandler::GetHandlers(const extensions::Extension* extension) {
   FileBrowserHandlerInfo* info = static_cast<FileBrowserHandlerInfo*>(
       extension->GetManifestData(keys::kFileBrowserHandlers));
   if (info)
     return &info->file_browser_handlers;
   return NULL;
 }
 
-std::string* FileBrowserHandler::g_test_extension_id_ = NULL;
-
 FileBrowserHandlerParser::FileBrowserHandlerParser() {
 }
 
 FileBrowserHandlerParser::~FileBrowserHandlerParser() {
 }
 
 namespace {
 
 FileBrowserHandler* LoadFileBrowserHandler(
     const std::string& extension_id,
@@ skipping 82 matching lines @@
       bool allowed = path == "/*" || path == "/*.*" ||
           (path.compare(0, 3, "/*.") == 0 &&
            path.find_first_of('*', 3) == std::string::npos);
       if (!allowed) {
         *error = extensions::ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, filter);
         return NULL;
       }
       result->AddPattern(pattern);
     }
-
-    // Initialize MIME type filters (optional).
-    // NOTE: This is only used by QuickOffice extension to register MIME types
-    // it can handle by directly downloading them. It will *not* be used in File
-    // Manager UI. This is why file filters are mandatory even when MIME type
-    // filters are specified.
-    const ListValue* mime_type_filters = NULL;
-    if (file_browser_handler->HasKey(keys::kMIMETypes)) {
-      if (!FileBrowserHandler::ExtensionWhitelistedForMIMETypes(extension_id)) {
-        *error = ASCIIToUTF16(
-            errors::kNoPermissionForFileBrowserHandlerMIMETypes);
-        return NULL;
-      }
-
-      if (!file_browser_handler->GetList(keys::kMIMETypes,
-                                         &mime_type_filters)) {
-        *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandlerMIMETypes);
-        return NULL;
-      }
-
-      for (size_t i = 0; i < mime_type_filters->GetSize(); ++i) {
-        std::string filter;
-        if (!mime_type_filters->GetString(i, &filter)) {
-          *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandlerMIMETypes);
-          return NULL;
-        }
-        result->AddMIMEType(filter);
-      }
-    }
   }
 
   std::string default_icon;
   // Read the file browser action |default_icon| (optional).
   if (file_browser_handler->HasKey(keys::kPageActionDefaultIcon)) {
     if (!file_browser_handler->GetString(
             keys::kPageActionDefaultIcon, &default_icon) ||
         default_icon.empty()) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return NULL;
@@ skipping 45 matching lines @@
     return false;  // Failed to parse file browser actions definition.
   }
 
   extension->SetManifestData(keys::kFileBrowserHandlers, info.release());
   return true;
 }
 
 const std::vector<std::string> FileBrowserHandlerParser::Keys() const {
   return SingleKey(keys::kFileBrowserHandlers);
 }