Take 2 at implementing activeTab.

chrome/browser/extensions/execute_code_in_tab_function.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/extensions/execute_code_in_tab_function.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 72 matching lines @@
                                       &browser, NULL, &contents, NULL)) {
       return false;
     }
   }
 
   // NOTE: This can give the wrong answer due to race conditions, but it is OK,
   // we check again in the renderer.
   CHECK(browser);
   CHECK(contents);
   if (!GetExtension()->CanExecuteScriptOnPage(
-          contents->web_contents()->GetURL(), NULL, &error_)) {
+          contents->web_contents()->GetURL(), execute_tab_id_, NULL, &error_)) {
     return false;
   }
 
   if (script_info->HasKey(keys::kAllFramesKey)) {
     if (!script_info->GetBoolean(keys::kAllFramesKey, &all_frames_))
       return false;
   }
 
   if (script_info->HasKey(keys::kRunAtKey)) {
     std::string run_string;
     EXTENSION_FUNCTION_VALIDATE(script_info->GetString(
           keys::kRunAtKey, &run_string));
 
     if (run_string == extension_manifest_values::kRunAtDocumentStart)
       run_at_ = UserScript::DOCUMENT_START;
     else if (run_string == extension_manifest_values::kRunAtDocumentEnd)
       run_at_ = UserScript::DOCUMENT_END;
     else if (run_string == extension_manifest_values::kRunAtDocumentIdle)
       run_at_ = UserScript::DOCUMENT_IDLE;
     else
       EXTENSION_FUNCTION_VALIDATE(false);
   }
 
   std::string code_string;
   if (script_info->HasKey(keys::kCodeKey)) {
     if (!script_info->GetString(keys::kCodeKey, &code_string))
       return false;
   }
 
-  if (!code_string.empty()) {
-    if (!Execute(code_string))
-      return false;
-    return true;
-  }
+  if (!code_string.empty())
+    return Execute(code_string);
 
   std::string relative_path;
   if (script_info->HasKey(keys::kFileKey)) {
     if (!script_info->GetString(keys::kFileKey, &relative_path))
       return false;
     resource_ = GetExtension()->GetResource(relative_path);
   }
   if (resource_.extension_root().empty() || resource_.relative_path().empty()) {
     error_ = keys::kNoCodeOrFileToExecuteError;
     return false;
@@ skipping 59 matching lines @@
   // anything to localize.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ExecuteCodeInTabFunction::DidLoadAndLocalizeFile, this,
                  true, css_data));
 }
 
 void ExecuteCodeInTabFunction::DidLoadAndLocalizeFile(bool success,
                                                       const std::string& data) {
   if (success) {
-    Execute(data);
+    if (!Execute(data))
+      SendResponse(false);
   } else {
 #if defined(OS_POSIX)
     // TODO(viettrungluu): bug: there's no particular reason the path should be
     // UTF-8, in which case this may fail.
     error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kLoadFileError,
         resource_.relative_path().value());
 #elif defined(OS_WIN)
     error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kLoadFileError,
         WideToUTF8(resource_.relative_path().value()));
 #endif  // OS_WIN
     SendResponse(false);
   }
 }
 
 bool ExecuteCodeInTabFunction::Execute(const std::string& code_string) {
   TabContentsWrapper* contents = NULL;
   Browser* browser = NULL;
 
   bool success = ExtensionTabUtil::GetTabById(
       execute_tab_id_, profile(), include_incognito(), &browser, NULL,
       &contents, NULL) && contents && browser;
 
-  if (!success) {
-    SendResponse(false);
+  if (!success)
     return false;
-  }
 
   const extensions::Extension* extension = GetExtension();
-  if (!extension) {
-    SendResponse(false);
+  if (!extension)
     return false;
-  }
 
   ScriptExecutor::ScriptType script_type = ScriptExecutor::JAVASCRIPT;
   std::string function_name = name();
   if (function_name == TabsInsertCSSFunction::function_name()) {
     script_type = ScriptExecutor::CSS;
   } else if (function_name != TabsExecuteScriptFunction::function_name()) {
     NOTREACHED();
   }
 
   contents->extension_tab_helper()->script_executor()->ExecuteScript(
       extension->id(),
       script_type,
       code_string,
       all_frames_ ? ScriptExecutor::ALL_FRAMES : ScriptExecutor::TOP_FRAME,
       run_at_,
       ScriptExecutor::ISOLATED_WORLD,
       base::Bind(&ExecuteCodeInTabFunction::OnExecuteCodeFinished, this));
   return true;
 }