This source file includes following definitions.
- create
- m_domDataStore
- mainWorld
- isolatedWorldMap
- allWorldsInMainThread
- dispose
- isIsolatedWorldId
- ensureIsolatedWorld
- isolatedWorldSecurityOrigins
- isolatedWorldSecurityOrigin
- setIsolatedWorldSecurityOrigin
- clearIsolatedWorldSecurityOrigin
- isolatedWorldContentSecurityPolicies
- isolatedWorldHasContentSecurityPolicy
- setIsolatedWorldContentSecurityPolicy
- clearIsolatedWorldContentSecurityPolicy
#include "config.h"
#include "bindings/v8/DOMWrapperWorld.h"
#include "V8Window.h"
#include "bindings/v8/DOMDataStore.h"
#include "bindings/v8/ScriptController.h"
#include "bindings/v8/V8Binding.h"
#include "bindings/v8/V8DOMActivityLogger.h"
#include "bindings/v8/V8DOMWrapper.h"
#include "bindings/v8/V8WindowShell.h"
#include "bindings/v8/WrapperTypeInfo.h"
#include "core/dom/ExecutionContext.h"
#include "wtf/HashTraits.h"
#include "wtf/StdLibExtras.h"
namespace WebCore {
unsigned DOMWrapperWorld::isolatedWorldCount = 0;
DOMWrapperWorld* DOMWrapperWorld::worldOfInitializingWindow = 0;
PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::create(int worldId, int extensionGroup)
{
return adoptRef(new DOMWrapperWorld(worldId, extensionGroup));
}
DOMWrapperWorld::DOMWrapperWorld(int worldId, int extensionGroup)
: m_worldId(worldId)
, m_extensionGroup(extensionGroup)
, m_domDataStore(adoptPtr(new DOMDataStore(isMainWorld())))
{
}
DOMWrapperWorld& DOMWrapperWorld::mainWorld()
{
ASSERT(isMainThread());
DEFINE_STATIC_REF(DOMWrapperWorld, cachedMainWorld, (DOMWrapperWorld::create(MainWorldId, mainWorldExtensionGroup)));
return *cachedMainWorld;
}
typedef HashMap<int, DOMWrapperWorld*> WorldMap;
static WorldMap& isolatedWorldMap()
{
ASSERT(isMainThread());
DEFINE_STATIC_LOCAL(WorldMap, map, ());
return map;
}
void DOMWrapperWorld::allWorldsInMainThread(Vector<RefPtr<DOMWrapperWorld> >& worlds)
{
ASSERT(isMainThread());
worlds.append(&mainWorld());
WorldMap& isolatedWorlds = isolatedWorldMap();
for (WorldMap::iterator it = isolatedWorlds.begin(); it != isolatedWorlds.end(); ++it)
worlds.append(it->value);
}
DOMWrapperWorld::~DOMWrapperWorld()
{
ASSERT(!isMainWorld());
dispose();
if (!isIsolatedWorld())
return;
WorldMap& map = isolatedWorldMap();
WorldMap::iterator i = map.find(m_worldId);
if (i == map.end()) {
ASSERT_NOT_REACHED();
return;
}
ASSERT(i->value == this);
map.remove(i);
isolatedWorldCount--;
ASSERT(map.size() == isolatedWorldCount);
}
void DOMWrapperWorld::dispose()
{
m_domDataStore.clear();
}
#ifndef NDEBUG
static bool isIsolatedWorldId(int worldId)
{
return MainWorldId < worldId && worldId < IsolatedWorldIdLimit;
}
#endif
PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::ensureIsolatedWorld(int worldId, int extensionGroup)
{
ASSERT(isIsolatedWorldId(worldId));
WorldMap& map = isolatedWorldMap();
WorldMap::AddResult result = map.add(worldId, 0);
RefPtr<DOMWrapperWorld> world = result.storedValue->value;
if (world) {
ASSERT(world->worldId() == worldId);
ASSERT(world->extensionGroup() == extensionGroup);
return world.release();
}
world = DOMWrapperWorld::create(worldId, extensionGroup);
result.storedValue->value = world.get();
isolatedWorldCount++;
ASSERT(map.size() == isolatedWorldCount);
return world.release();
}
typedef HashMap<int, RefPtr<SecurityOrigin> > IsolatedWorldSecurityOriginMap;
static IsolatedWorldSecurityOriginMap& isolatedWorldSecurityOrigins()
{
ASSERT(isMainThread());
DEFINE_STATIC_LOCAL(IsolatedWorldSecurityOriginMap, map, ());
return map;
}
SecurityOrigin* DOMWrapperWorld::isolatedWorldSecurityOrigin()
{
ASSERT(this->isIsolatedWorld());
IsolatedWorldSecurityOriginMap& origins = isolatedWorldSecurityOrigins();
IsolatedWorldSecurityOriginMap::iterator it = origins.find(worldId());
return it == origins.end() ? 0 : it->value.get();
}
void DOMWrapperWorld::setIsolatedWorldSecurityOrigin(int worldId, PassRefPtr<SecurityOrigin> securityOrigin)
{
ASSERT(isIsolatedWorldId(worldId));
if (securityOrigin)
isolatedWorldSecurityOrigins().set(worldId, securityOrigin);
else
isolatedWorldSecurityOrigins().remove(worldId);
}
void DOMWrapperWorld::clearIsolatedWorldSecurityOrigin(int worldId)
{
ASSERT(isIsolatedWorldId(worldId));
isolatedWorldSecurityOrigins().remove(worldId);
}
typedef HashMap<int, bool> IsolatedWorldContentSecurityPolicyMap;
static IsolatedWorldContentSecurityPolicyMap& isolatedWorldContentSecurityPolicies()
{
ASSERT(isMainThread());
DEFINE_STATIC_LOCAL(IsolatedWorldContentSecurityPolicyMap, map, ());
return map;
}
bool DOMWrapperWorld::isolatedWorldHasContentSecurityPolicy()
{
ASSERT(this->isIsolatedWorld());
IsolatedWorldContentSecurityPolicyMap& policies = isolatedWorldContentSecurityPolicies();
IsolatedWorldContentSecurityPolicyMap::iterator it = policies.find(worldId());
return it == policies.end() ? false : it->value;
}
void DOMWrapperWorld::setIsolatedWorldContentSecurityPolicy(int worldId, const String& policy)
{
ASSERT(isIsolatedWorldId(worldId));
if (!policy.isEmpty())
isolatedWorldContentSecurityPolicies().set(worldId, true);
else
isolatedWorldContentSecurityPolicies().remove(worldId);
}
void DOMWrapperWorld::clearIsolatedWorldContentSecurityPolicy(int worldId)
{
ASSERT(isIsolatedWorldId(worldId));
isolatedWorldContentSecurityPolicies().remove(worldId);
}
}