Add support for a "split" incognito behavior for extensions.

chrome/renderer/extensions/extension_process_bindings.cc

 // Copyright (c) 2010 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_process_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 44 matching lines @@
 
 // A map of extension ID to vector of page action ids.
 typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
 
 // A map of permission name to whether its enabled for this extension.
 typedef std::map<std::string, bool> PermissionsMap;
 
 // A map of extension ID to permissions map.
 typedef std::map<std::string, PermissionsMap> ExtensionPermissionsMap;
 
-// A map of extension ID to whether this extension was enabled in incognito.
-typedef std::map<std::string, bool> IncognitoEnabledMap;
+// A map of extension ID to whether this extension can access data from other
+// profiles.
+typedef std::map<std::string, bool> CrossProfileAccessMap;
 
 const char kExtensionName[] = "chrome/ExtensionProcessBindings";
 const char* kExtensionDeps[] = {
   BaseJsV8Extension::kName,
   EventBindings::kName,
   JsonSchemaJsV8Extension::kName,
   RendererExtensionBindings::kName,
   ExtensionApiTestV8Extension::kName,
 };
 
@@ skipping 10 matching lines @@
   "browserActions",
   "i18n",
   "devtools",
   "test"
 };
 
 struct SingletonData {
   std::set<std::string> function_names_;
   PageActionIdMap page_action_ids_;
   ExtensionPermissionsMap permissions_;
-  IncognitoEnabledMap incognito_enabled_map_;
+  CrossProfileAccessMap cross_profile_access_map_;
 };
 
 static std::set<std::string>* GetFunctionNameSet() {
   return &Singleton<SingletonData>()->function_names_;
 }
 
 static PageActionIdMap* GetPageActionMap() {
   return &Singleton<SingletonData>()->page_action_ids_;
 }
 
 static PermissionsMap* GetPermissionsMap(const std::string& extension_id) {
   return &Singleton<SingletonData>()->permissions_[extension_id];
 }
 
-static IncognitoEnabledMap* GetIncognitoEnabledMap() {
-  return &Singleton<SingletonData>()->incognito_enabled_map_;
+static CrossProfileAccessMap* GetCrossProfileAccessMap() {
+  return &Singleton<SingletonData>()->cross_profile_access_map_;
 }
 
 static void GetActiveExtensionIDs(std::set<std::string>* extension_ids) {
   ExtensionPermissionsMap& permissions =
       Singleton<SingletonData>()->permissions_;
 
   for (ExtensionPermissionsMap::iterator iter = permissions.begin();
        iter != permissions.end(); ++iter) {
     extension_ids->insert(iter->first);
   }
@@ skipping 133 matching lines @@
     } else if (name->Equals(v8::String::New("GetRenderViewId"))) {
       return v8::FunctionTemplate::New(GetRenderViewId);
     } else if (name->Equals(v8::String::New("GetPopupView"))) {
       return v8::FunctionTemplate::New(GetPopupView);
     } else if (name->Equals(v8::String::New("GetPopupParentWindow"))) {
       return v8::FunctionTemplate::New(GetPopupParentWindow);
     } else if (name->Equals(v8::String::New("SetIconCommon"))) {
       return v8::FunctionTemplate::New(SetIconCommon);
     } else if (name->Equals(v8::String::New("IsExtensionProcess"))) {
       return v8::FunctionTemplate::New(IsExtensionProcess);
+    } else if (name->Equals(v8::String::New("IsIncognitoProcess"))) {
+      return v8::FunctionTemplate::New(IsIncognitoProcess);
     }
 
     return ExtensionBase::GetNativeFunction(name);
   }
 
  private:
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
     return v8::String::New(GetStringResource<IDR_EXTENSION_API_JSON>());
   }
@@ skipping 278 matching lines @@
       return v8::Undefined();
     return v8::Integer::New(renderview->routing_id());
   }
 
   static v8::Handle<v8::Value> IsExtensionProcess(const v8::Arguments& args) {
     bool retval = false;
     if (EventBindings::GetRenderThread())
       retval = EventBindings::GetRenderThread()->IsExtensionProcess();
     return v8::Boolean::New(retval);
   }
+
+  static v8::Handle<v8::Value> IsIncognitoProcess(const v8::Arguments& args) {
+    bool retval = false;
+    if (EventBindings::GetRenderThread())
+      retval = EventBindings::GetRenderThread()->IsIncognitoProcess();
+    return v8::Boolean::New(retval);
+  }
 };
 
 }  // namespace
 
 v8::Extension* ExtensionProcessBindings::Get() {
   static v8::Extension* extension = new ExtensionImpl();
   return extension;
 }
 
 void ExtensionProcessBindings::GetActiveExtensions(
     std::set<std::string>* extension_ids) {
   GetActiveExtensionIDs(extension_ids);
 }
 
 void ExtensionProcessBindings::SetFunctionNames(
     const std::vector<std::string>& names) {
   ExtensionImpl::SetFunctionNames(names);
 }
 
 void ExtensionProcessBindings::SetIncognitoEnabled(
-    const std::string& extension_id, bool enabled) {
-  (*GetIncognitoEnabledMap())[extension_id] = enabled;
+    const std::string& extension_id, bool enabled, bool incognito_split_mode) {
+  // We allow the extension to see events and data from another profile iff it
+  // uses "spanning" behavior and it has incognito access. "split" mode
+  // extensions only see events for a matching profile.
+  (*GetCrossProfileAccessMap())[extension_id] =
+      enabled && !incognito_split_mode;
 }
 
 // static
-bool ExtensionProcessBindings::HasIncognitoEnabled(
+bool ExtensionProcessBindings::AllowCrossProfile(
     const std::string& extension_id) {
-  return (!extension_id.empty() && (*GetIncognitoEnabledMap())[extension_id]);
+  return (!extension_id.empty() && (*GetCrossProfileAccessMap())[extension_id]);
 }
 
 // static
 void ExtensionProcessBindings::HandleResponse(int request_id, bool success,
                                               const std::string& response,
                                               const std::string& error) {
   PendingRequestMap& pending_requests = GetPendingRequestMap();
   PendingRequestMap::iterator request = pending_requests.find(request_id);
   if (request == pending_requests.end())
     return;  // The frame went away.
@@ skipping 108 matching lines @@
       const std::string& function_name) {
   static const char kMessage[] =
       "You do not have permission to use '%s'. Be sure to declare"
       " in your manifest what permissions you need.";
   std::string error_msg = StringPrintf(kMessage, function_name.c_str());
 
   return v8::ThrowException(v8::Exception::Error(
       v8::String::New(error_msg.c_str())));
 }