Loads local resources from current locale subtree if available, if not it fal...

chrome/common/extensions/extension.cc

 // Copyright (c) 2009 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/common/extensions/extension.h"
 
 #include "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
 #include "base/third_party/nss/blapi.h"
 #include "base/third_party/nss/sha256.h"
+#include "chrome/browser/extensions/extension_l10n_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/base64.h"
-#include "net/base/net_util.h"
 
 #if defined(OS_WIN)
 #include "base/registry.h"
 #endif
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
 namespace {
@@ skipping 240 matching lines @@
          ++script_index) {
       Value* value;
       std::wstring relative;
       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJs,
             IntToString(definition_index), IntToString(script_index));
         return false;
       }
       // TODO(georged): Make GetResourceURL accept wstring too
       GURL url = GetResourceURL(WideToUTF8(relative));
-      FilePath path = GetResourcePath(WideToUTF8(relative));
-      result->js_scripts().push_back(UserScript::File(path, url));
+      ExtensionResource resource = GetResource(WideToUTF8(relative));
+      result->js_scripts().push_back(UserScript::File(resource, url));
     }
   }
 
   if (css) {
     for (size_t script_index = 0; script_index < css->GetSize();
          ++script_index) {
       Value* value;
       std::wstring relative;
       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidCss,
             IntToString(definition_index), IntToString(script_index));
         return false;
       }
       // TODO(georged): Make GetResourceURL accept wstring too
       GURL url = GetResourceURL(WideToUTF8(relative));
-      FilePath path = GetResourcePath(WideToUTF8(relative));
-      result->css_scripts().push_back(UserScript::File(path, url));
+      ExtensionResource resource = GetResource(WideToUTF8(relative));
+      result->css_scripts().push_back(UserScript::File(resource, url));
     }
   }
 
   return true;
 }
 
 // Helper method that loads a PageAction or BrowserAction object from a
 // dictionary in the page_actions list or browser_action key of the manifest.
 ExtensionAction* Extension::LoadExtensionActionHelper(
     const DictionaryValue* page_action, int definition_index,
@@ skipping 106 matching lines @@
   while (iter != source.end_keys()) {
     std::wstring key = (*iter);
     if (theme_keys.find(key) == theme_keys.end())
       return true;
     ++iter;
   }
   return false;
 }
 
 // static
-FilePath Extension::GetResourcePath(const FilePath& extension_path,
-                                    const std::string& relative_path) {
-  // Build up a file:// URL and convert that back to a FilePath.  This avoids
-  // URL encoding and path separator issues.
-
-  // Convert the extension's root to a file:// URL.
-  GURL extension_url = net::FilePathToFileURL(extension_path);
-  if (!extension_url.is_valid())
-    return FilePath();
-
-  // Append the requested path.
-  GURL::Replacements replacements;
-  std::string new_path(extension_url.path());
-  new_path += "/";
-  new_path += relative_path;
-  replacements.SetPathStr(new_path);
-  GURL file_url = extension_url.ReplaceComponents(replacements);
-  if (!file_url.is_valid())
-    return FilePath();
-
-  // Convert the result back to a FilePath.
-  FilePath ret_val;
-  if (!net::FileURLToFilePath(file_url, &ret_val))
-    return FilePath();
-
-  // Double-check that the path we ended up with is actually inside the
-  // extension root.
-  if (!extension_path.IsParent(ret_val))
-    return FilePath();
-
-  return ret_val;
+ExtensionResource Extension::GetResource(const FilePath& extension_path,
+                                         const std::string& relative_path) {
+  FilePath relative_resource_path;
+  return ExtensionResource(extension_path,
+                           relative_resource_path.AppendASCII(relative_path));
 }
 
 Extension::Extension(const FilePath& path)
     : is_theme_(false), background_page_ready_(false) {
   DCHECK(path.IsAbsolute());
   location_ = INVALID;
 
 #if defined(OS_WIN)
   // Normalize any drive letter to upper-case. We do this for consistency with
   // net_utils::FilePathToFileURL(), which does the same thing, to make string
@@ skipping 641 matching lines @@
 
 void Extension::SetBackgroundPageReady() {
   DCHECK(!background_url().is_empty());
   background_page_ready_ = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
       Source<Extension>(this),
       NotificationService::NoDetails());
 }
 
-FilePath Extension::GetIconPath(Icons icon) {
+ExtensionResource Extension::GetIconPath(Icons icon) {
   std::map<int, std::string>::const_iterator iter =
       icons_.find(Extension::EXTENSION_ICON_LARGE);
   if (iter == icons_.end())
-    return FilePath();
-  return GetResourcePath(iter->second);
+    return ExtensionResource();
+  return GetResource(iter->second);
 }
 
 bool Extension::CanAccessHost(const GURL& url) const {
   for (HostPermissions::const_iterator host = host_permissions_.begin();
        host != host_permissions_.end(); ++host) {
     if (host->MatchesUrl(url))
       return true;
   }
 
   return false;
@@ skipping 29 matching lines @@
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern) {
       if (pattern->match_subdomains() && pattern->host().empty())
         return true;
     }
   }
 
   return false;
 }