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);

[Aaron Boodman, 2012/06/06 01:03:13]

heh.

 
   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 82 matching lines @@
 }
 
 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);

[Aaron Boodman, 2012/06/06 01:03:13]

This seems like it would be a behavior change.

[not at google - send to devlin, 2012/06/06 07:38:40]

Don't think so*.  It think it's an existing bug in this code that causes
SendResponse(false) to be called twice (in extension_function.cc, if RunImpl()
returns false, which happens when this method returns false, SendResponse(false)
gets called).

* it actually was, I needed to call it from the other place that Execute() is
called from (DidLoadAndLocalizeFile).  Fixed that.

+  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;
 }