Enable <webview>.executeScript outside of Apps and Extensions [2]

extensions/browser/api/execute_code_function.cc

 // Copyright 2014 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.
 
 #ifndef EXTENSIONS_BROWSER_API_EXECUTE_CODE_FUNCTION_IMPL_H_
 #define EXTENSIONS_BROWSER_API_EXECUTE_CODE_FUNCTION_IMPL_H_
 
 #include "extensions/browser/api/execute_code_function.h"
 
 #include "extensions/browser/component_extension_resource_manager.h"
@@ skipping 25 matching lines @@
 using core_api::extension_types::InjectDetails;
 
 ExecuteCodeFunction::ExecuteCodeFunction() {
 }
 
 ExecuteCodeFunction::~ExecuteCodeFunction() {
 }
 
 void ExecuteCodeFunction::DidLoadFile(bool success, const std::string& data) {
   if (!success || !details_->file) {
-    DidLoadAndLocalizeFile(success, data);
+    DidLoadAndLocalizeFile(
+        resource_.relative_path().AsUTF8Unsafe(), success, data);
     return;
   }
 
   ScriptExecutor::ScriptType script_type =
       ShouldInsertCSS() ? ScriptExecutor::CSS : ScriptExecutor::JAVASCRIPT;
 
   std::string extension_id;
   base::FilePath extension_path;
   std::string extension_default_locale;
   if (extension()) {
@@ skipping 38 matching lines @@
   file_url_ = net::FilePathToFileURL(resource_.GetFilePath());
 
   // Call back DidLoadAndLocalizeFile on the UI thread. The success parameter
   // is always true, because if loading had failed, we wouldn't have had
   // anything to localize.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ExecuteCodeFunction::DidLoadAndLocalizeFile,
                  this,
+                 resource_.relative_path().AsUTF8Unsafe(),
                  true,
                  localized_data));
 }
 
-void ExecuteCodeFunction::DidLoadAndLocalizeFile(bool success,
+void ExecuteCodeFunction::DidLoadAndLocalizeFile(const std::string& file,
+                                                 bool success,
                                                  const std::string& data) {
   if (success) {
     if (!base::IsStringUTF8(data)) {
-      error_ = ErrorUtils::FormatErrorMessage(
-          kBadFileEncodingError, resource_.relative_path().AsUTF8Unsafe());
+      error_ = ErrorUtils::FormatErrorMessage(kBadFileEncodingError, file);
       SendResponse(false);
     } else if (!Execute(data))
       SendResponse(false);
   } else {
     // TODO(viettrungluu): bug: there's no particular reason the path should be
     // UTF-8, in which case this may fail.
-    error_ = ErrorUtils::FormatErrorMessage(
-        kLoadFileError, resource_.relative_path().AsUTF8Unsafe());
+    error_ = ErrorUtils::FormatErrorMessage(kLoadFileError, file);
     SendResponse(false);
   }
 }
 
 bool ExecuteCodeFunction::Execute(const std::string& code_string) {
   ScriptExecutor* executor = GetScriptExecutor();
   if (!executor)
     return false;
 
   if (!extension() && !IsWebView())
@@ skipping 65 matching lines @@
 
   if (!CanExecuteScriptOnPage())
     return false;
 
   if (details_->code.get())
     return Execute(*details_->code);
 
   if (!details_->file.get())
     return false;
 
-  if (!extension())
-    return false;
+  return LoadFile(*details_->file);
+}
 
-  resource_ = extension()->GetResource(*details_->file);
+bool ExecuteCodeFunction::LoadFile(const std::string& file) {
+  resource_ = extension()->GetResource(file);
 
   if (resource_.extension_root().empty() || resource_.relative_path().empty()) {
     error_ = kNoCodeOrFileToExecuteError;
     return false;
   }
 
   int resource_id;
   const ComponentExtensionResourceManager*
       component_extension_resource_manager =
           ExtensionsBrowserClient::Get()
@@ skipping 19 matching lines @@
                                                 const base::ListValue& result) {
   if (!error.empty())
     SetError(error);
 
   SendResponse(error.empty());
 }
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_EXECUTE_CODE_FUNCTION_IMPL_H_