Take 2 at implementing activeTab.

chrome/renderer/extensions/extension_dispatcher.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/renderer/extensions/extension_dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 22 matching lines @@
 #include "chrome/renderer/extensions/extension_request_sender.h"
 #include "chrome/renderer/extensions/file_browser_handler_custom_bindings.h"
 #include "chrome/renderer/extensions/file_browser_private_custom_bindings.h"
 #include "chrome/renderer/extensions/i18n_custom_bindings.h"
 #include "chrome/renderer/extensions/media_gallery_custom_bindings.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/page_actions_custom_bindings.h"
 #include "chrome/renderer/extensions/page_capture_custom_bindings.h"
 #include "chrome/renderer/extensions/send_request_natives.h"
 #include "chrome/renderer/extensions/set_icon_natives.h"
+#include "chrome/renderer/extensions/tab_finder.h"
 #include "chrome/renderer/extensions/tabs_custom_bindings.h"
 #include "chrome/renderer/extensions/tts_custom_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "chrome/renderer/extensions/web_request_custom_bindings.h"
 #include "chrome/renderer/extensions/webstore_bindings.h"
 #include "chrome/renderer/module_system.h"
 #include "chrome/renderer/native_handler.h"
 #include "chrome/renderer/resource_bundle_source_map.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
@@ skipping 12 matching lines @@
 
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebScopedUserGesture;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebVector;
 using WebKit::WebView;
 using content::RenderThread;
+using content::RenderView;
 using extensions::ApiDefinitionsNatives;
 using extensions::AppWindowCustomBindings;
 using extensions::ContextMenusCustomBindings;
 using extensions::Extension;
 using extensions::ExperimentalAppCustomBindings;
 using extensions::ExperimentalUsbCustomBindings;
 using extensions::ExtensionAPI;
 using extensions::ExtensionCustomBindings;
 using extensions::Feature;
 using extensions::FileBrowserHandlerCustomBindings;
 using extensions::FileBrowserPrivateCustomBindings;
 using extensions::I18NCustomBindings;
 using extensions::MiscellaneousBindings;
 using extensions::MediaGalleryCustomBindings;
 using extensions::PageActionsCustomBindings;
 using extensions::PageCaptureCustomBindings;
 using extensions::SendRequestNatives;
 using extensions::SetIconNatives;
 using extensions::TTSCustomBindings;
+using extensions::TabFinder;
 using extensions::TabsCustomBindings;
 using extensions::UpdatedExtensionPermissionsInfo;
 using extensions::WebRequestCustomBindings;
 
 namespace {
 
 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
 static const char kEventDispatchFunction[] = "Event.dispatchJSON";
 static const char kOnUnloadEvent[] = "runtime.onBackgroundPageUnloadingSoon";
@@ skipping 42 matching lines @@
     RouteFunction("DecrementKeepaliveCount",
         base::Bind(&LazyBackgroundPageNativeHandler::DecrementKeepaliveCount,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> IncrementKeepaliveCount(const v8::Arguments& args) {
     ChromeV8Context* context =
         extension_dispatcher()->v8_context_set().GetCurrent();
     if (!context)
       return v8::Undefined();
-    content::RenderView* render_view = context->GetRenderView();
+    RenderView* render_view = context->GetRenderView();
     if (IsContextLazyBackgroundPage(render_view, context->extension())) {
       render_view->Send(new ExtensionHostMsg_IncrementLazyKeepaliveCount(
           render_view->GetRoutingID()));
     }
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> DecrementKeepaliveCount(const v8::Arguments& args) {
     ChromeV8Context* context =
         extension_dispatcher()->v8_context_set().GetCurrent();
     if (!context)
       return v8::Undefined();
-    content::RenderView* render_view = context->GetRenderView();
+    RenderView* render_view = context->GetRenderView();
     if (IsContextLazyBackgroundPage(render_view, context->extension())) {
       render_view->Send(new ExtensionHostMsg_DecrementLazyKeepaliveCount(
           render_view->GetRoutingID()));
     }
     return v8::Undefined();
   }
 
  private:
-  bool IsContextLazyBackgroundPage(content::RenderView* render_view,
+  bool IsContextLazyBackgroundPage(RenderView* render_view,
                                    const Extension* extension) {
     if (!render_view)
       return false;
 
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
     return (extension && extension->has_lazy_background_page() &&
             helper->view_type() == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   }
 };
 
@@ skipping 69 matching lines @@
     IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect,
                         OnDispatchOnDisconnect)
     IPC_MESSAGE_HANDLER(ExtensionMsg_SetFunctionNames, OnSetFunctionNames)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnUnloaded)
     IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
                         OnSetScriptingWhitelist)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_SetTabSpecificPermissions,
+                        OnSetTabSpecificPermissions)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_ClearTabSpecificPermissions,
+                        OnClearTabSpecificPermissions)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UsingWebRequestAPI, OnUsingWebRequestAPI)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ShouldUnload, OnShouldUnload)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Unload, OnUnload)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
@@ skipping 61 matching lines @@
   if (is_extension_process_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   // Tell the browser process when an event has been dispatched with a lazy
   // background page active.
   const Extension* extension = extensions_.GetByID(extension_id);
   if (extension && extension->has_lazy_background_page() &&
       function_name == kEventDispatchFunction) {
-    content::RenderView* background_view =
+    RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 void ExtensionDispatcher::OnDispatchOnConnect(
     int target_port_id,
@@ skipping 409 matching lines @@
   // whitelist entries need to be updated when the kManagement permission
   // changes.
   if (extension->HasAPIPermission(ExtensionAPIPermission::kManagement)) {
     WebSecurityPolicy::addOriginAccessWhitelistEntry(
         extension->url(),
         WebString::fromUTF8(chrome::kChromeUIScheme),
         WebString::fromUTF8(chrome::kChromeUIExtensionIconHost),
         false);
   }
 
-  UpdateOriginPermissions(UpdatedExtensionPermissionsInfo::ADDED,
-                          extension,
-                          extension->GetActivePermissions()->explicit_hosts());
+  AddOrRemoveOriginPermissions(
+      UpdatedExtensionPermissionsInfo::ADDED,
+      extension,
+      *extension->GetActiveHostPermissionsForAllTabs());
 }
 
-void ExtensionDispatcher::UpdateOriginPermissions(
+void ExtensionDispatcher::AddOrRemoveOriginPermissions(
     UpdatedExtensionPermissionsInfo::Reason reason,
     const Extension* extension,
     const URLPatternSet& origins) {
   for (URLPatternSet::const_iterator i = origins.begin();
        i != origins.end(); ++i) {
     const char* schemes[] = {
       chrome::kHttpScheme,
       chrome::kHttpsScheme,
       chrome::kFileScheme,
       chrome::kChromeUIScheme,
@@ skipping 15 matching lines @@
 void ExtensionDispatcher::OnUpdatePermissions(
     int reason_id,
     const std::string& extension_id,
     const ExtensionAPIPermissionSet& apis,
     const URLPatternSet& explicit_hosts,
     const URLPatternSet& scriptable_hosts) {
   const Extension* extension = extensions_.GetByID(extension_id);
   if (!extension)
     return;
 
+  // General permissions.
   scoped_refptr<const ExtensionPermissionSet> delta =
       new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
   scoped_refptr<const ExtensionPermissionSet> old_active =
       extension->GetActivePermissions();
   UpdatedExtensionPermissionsInfo::Reason reason =
       static_cast<UpdatedExtensionPermissionsInfo::Reason>(reason_id);
 
   const ExtensionPermissionSet* new_active = NULL;
-  if (reason == UpdatedExtensionPermissionsInfo::ADDED) {
-    new_active = ExtensionPermissionSet::CreateUnion(old_active, delta);
-  } else {
-    CHECK_EQ(UpdatedExtensionPermissionsInfo::REMOVED, reason);
-    new_active = ExtensionPermissionSet::CreateDifference(old_active, delta);
+  switch (reason) {
+    case UpdatedExtensionPermissionsInfo::ADDED:
+      new_active = ExtensionPermissionSet::CreateUnion(old_active, delta);
+      break;
+    case UpdatedExtensionPermissionsInfo::REMOVED:

[Aaron Boodman, 2012/06/08 05:31:30]

default: NOTREACHED() or CHECK(false)

[not at google - send to devlin, 2012/06/12 20:40:51]

clang catches missing enum branches as a compile error; better to leave
"default" out.

+      new_active = ExtensionPermissionSet::CreateDifference(old_active, delta);
+      break;
   }
 
+  URLPatternSet active_hosts_before =
+      *extension->GetActiveHostPermissionsForAllTabs();
+
   extension->SetActivePermissions(new_active);
-  UpdateOriginPermissions(reason, extension, explicit_hosts);
+
+  // Host permissions. These are different from the general permissions because
+  // they need to take into account the additional host permissions granted via
+  // the activeTab permission for various tabs.
+  URLPatternSet added_or_removed;
+  switch (reason) {
+    case UpdatedExtensionPermissionsInfo::ADDED:
+      URLPatternSet::CreateDifference(
+          *extension->GetActiveHostPermissionsForAllTabs(),
+          active_hosts_before,
+          &added_or_removed);
+      break;
+    case UpdatedExtensionPermissionsInfo::REMOVED:
+      URLPatternSet::CreateDifference(
+          active_hosts_before,
+          *extension->GetActiveHostPermissionsForAllTabs(),
+          &added_or_removed);
+      break;
+  }
+
+  AddOrRemoveOriginPermissions(reason, extension, added_or_removed);
+}
+
+void ExtensionDispatcher::OnSetTabSpecificPermissions(
+    int page_id,
+    int tab_id,
+    const std::string& extension_id,
+    const URLPatternSet& origin_set) {
+  // If this renderer contains the target tab then check against page_id to

[Aaron Boodman, 2012/06/08 05:31:30]

If we were keeping this code, probably the cleaner way to do it would be
translate the XHR-related temporary permissions into 'normal' permissions in the
browser and communicate them to the renderer that way. The renderer doesn't need
to know that a host permission update was because of activeTab or not.

The tab-specific permissions would only be communicated to the one renderer that
actually contains that tab, and this caveat would be unnecessary.

[not at google - send to devlin, 2012/06/12 20:40:51]

Yeah, we discussed this, but I'll write some of it down anyway.

It would definitely work to put a lot of the smarts in the browser to figure out
what to send each renderer. But it would be complicated.  I think it's easier to
keep the logic the same everywhere by having that stuff in Extension.

+  // avoid race conditions. The target tab is a more sensitive target since it
+  // has the opportunity to block executeScript calls. It would be nice to also
+  // check it on other renderers, but this obviously isn't possible.
+  RenderView* view = TabFinder::Find(tab_id);
+  if (view && view->GetPageId() != page_id) {
+    LOG(WARNING) <<
+        "Wrong page ID, wanted " << page_id << " but was " << view->GetPageId();

[not at google - send to devlin, 2012/06/07 08:49:22]

(Also removed this logging).

+    return;
+  }
+
+  const Extension* extension = extensions_.GetByID(extension_id);
+  if (!extension)
+    return;
+
+  URLPatternSet before = *extension->GetActiveHostPermissionsForAllTabs();
+
+  extension->SetTabSpecificHostPermissions(tab_id, origin_set);
+
+  // The origin permissions for XHR include the the union of host permissions
+  // for all tabs, granted via the activeTab permission.
+  URLPatternSet added;
+  URLPatternSet::CreateDifference(
+      *extension->GetActiveHostPermissionsForAllTabs(),
+      before,
+      &added);
+  AddOrRemoveOriginPermissions(UpdatedExtensionPermissionsInfo::ADDED,
+                               extension,
+                               added);
+}
+
+void ExtensionDispatcher::OnClearTabSpecificPermissions(
+    int tab_id,
+    const std::vector<std::string>& extension_ids) {
+  for (std::vector<std::string>::const_iterator it = extension_ids.begin();
+       it != extension_ids.end(); ++it) {
+    const Extension* extension = extensions_.GetByID(*it);
+    if (!extension)
+      continue;
+
+    URLPatternSet before = *extension->GetActiveHostPermissionsForAllTabs();
+
+    extension->ClearTabSpecificHostPermissions(tab_id);
+
+    // The origin permissions for XHR include the the union of host permissions
+    // for all tabs, granted via the activeTab permission.
+    URLPatternSet removed;
+    URLPatternSet::CreateDifference(
+        before,
+        *extension->GetActiveHostPermissionsForAllTabs(),
+        &removed);
+    AddOrRemoveOriginPermissions(UpdatedExtensionPermissionsInfo::REMOVED,
+                                 extension,
+                                 removed);
+  }
 }
 
 void ExtensionDispatcher::OnUpdateUserScripts(
     base::SharedMemoryHandle scripts) {
   DCHECK(base::SharedMemory::IsHandleValid(scripts)) << "Bad scripts handle";
   user_script_slave_->UpdateScripts(scripts);
   UpdateActiveExtensions();
 }
 
 void ExtensionDispatcher::UpdateActiveExtensions() {
@@ skipping 111 matching lines @@
   // APIs, they don't get extension bindings injected. If we end up here it
   // means that a sandboxed page somehow managed to invoke an API anyway, so
   // we should abort.
   WebKit::WebFrame* frame = context->web_frame();
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       UserScriptSlave::GetDataSourceURLForFrame(frame));
   CHECK(!extensions_.IsSandboxedPage(url_info));
 
   return true;
 }