1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/extensions/script_executor.h" 6 7 #include "base/callback.h" 8 #include "base/logging.h" 9 #include "base/pickle.h" 10 #include "chrome/common/extensions/extension_messages.h" 11 #include "content/public/browser/render_view_host.h" 12 #include "content/public/browser/web_contents.h" 13 #include "content/public/browser/web_contents_observer.h" 14 #include "ipc/ipc_message.h" 15 #include "ipc/ipc_message_macros.h" 16 17 namespace base { 18 class ListValue; 19 } // namespace base 20 21 namespace extensions { 22 23 namespace { 24 25 const char* kRendererDestroyed = "The tab was closed."; 26 27 // A handler for a single injection request. On creation this will send the 28 // injection request to the renderer, and it will be destroyed after either the 29 // corresponding response comes from the renderer, or the renderer is destroyed. 30 class Handler : public content::WebContentsObserver { 31 public: 32 Handler(ObserverList<TabHelper::ScriptExecutionObserver>* script_observers, 33 content::WebContents* web_contents, 34 const ExtensionMsg_ExecuteCode_Params& params, 35 const ScriptExecutor::ExecuteScriptCallback& callback) 36 : content::WebContentsObserver(web_contents), 37 script_observers_(AsWeakPtr(script_observers)), 38 extension_id_(params.extension_id), 39 request_id_(params.request_id), 40 callback_(callback) { 41 content::RenderViewHost* rvh = web_contents->GetRenderViewHost(); 42 rvh->Send(new ExtensionMsg_ExecuteCode(rvh->GetRoutingID(), params)); 43 } 44 45 virtual ~Handler() {} 46 47 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE { 48 // Unpack by hand to check the request_id, since there may be multiple 49 // requests in flight but only one is for this. 50 if (message.type() != ExtensionHostMsg_ExecuteCodeFinished::ID) 51 return false; 52 53 int message_request_id; 54 PickleIterator iter(message); 55 CHECK(message.ReadInt(&iter, &message_request_id)); 56 57 if (message_request_id != request_id_) 58 return false; 59 60 IPC_BEGIN_MESSAGE_MAP(Handler, message) 61 IPC_MESSAGE_HANDLER(ExtensionHostMsg_ExecuteCodeFinished, 62 OnExecuteCodeFinished) 63 IPC_END_MESSAGE_MAP() 64 return true; 65 } 66 67 virtual void WebContentsDestroyed(content::WebContents* tab) OVERRIDE { 68 base::ListValue val; 69 callback_.Run(kRendererDestroyed, -1, GURL(std::string()), val); 70 delete this; 71 } 72 73 private: 74 void OnExecuteCodeFinished(int request_id, 75 const std::string& error, 76 int32 on_page_id, 77 const GURL& on_url, 78 const base::ListValue& script_result) { 79 if (script_observers_.get() && error.empty()) { 80 TabHelper::ScriptExecutionObserver::ExecutingScriptsMap id_map; 81 id_map[extension_id_] = std::set<std::string>(); 82 FOR_EACH_OBSERVER(TabHelper::ScriptExecutionObserver, *script_observers_, 83 OnScriptsExecuted(web_contents(), 84 id_map, 85 on_page_id, 86 on_url)); 87 } 88 89 callback_.Run(error, on_page_id, on_url, script_result); 90 delete this; 91 } 92 93 base::WeakPtr<ObserverList<TabHelper::ScriptExecutionObserver> > 94 script_observers_; 95 std::string extension_id_; 96 int request_id_; 97 ScriptExecutor::ExecuteScriptCallback callback_; 98 }; 99 100 } // namespace 101 102 ScriptExecutor::ScriptExecutor( 103 content::WebContents* web_contents, 104 ObserverList<TabHelper::ScriptExecutionObserver>* script_observers) 105 : next_request_id_(0), 106 web_contents_(web_contents), 107 script_observers_(script_observers) {} 108 109 ScriptExecutor::~ScriptExecutor() {} 110 111 void ScriptExecutor::ExecuteScript( 112 const std::string& extension_id, 113 ScriptExecutor::ScriptType script_type, 114 const std::string& code, 115 ScriptExecutor::FrameScope frame_scope, 116 UserScript::RunLocation run_at, 117 ScriptExecutor::WorldType world_type, 118 bool is_web_view, 119 const ExecuteScriptCallback& callback) { 120 ExtensionMsg_ExecuteCode_Params params; 121 params.request_id = next_request_id_++; 122 params.extension_id = extension_id; 123 params.is_javascript = (script_type == JAVASCRIPT); 124 params.code = code; 125 params.all_frames = (frame_scope == ALL_FRAMES); 126 params.run_at = static_cast<int>(run_at); 127 params.in_main_world = (world_type == MAIN_WORLD); 128 params.is_web_view = is_web_view; 129 130 // Handler handles IPCs and deletes itself on completion. 131 new Handler(script_observers_, web_contents_, params, callback); 132 } 133 134 } // namespace extensions 135