Merge ExecutionContextClient and ExecutionContext

Source/core/dom/ExecutionContext.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2012 Google Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 49 matching lines @@
     }
     String m_errorMessage;
     int m_lineNumber;
     int m_columnNumber;
     int m_scriptId;
     String m_sourceURL;
     RefPtrWillBeMember<ScriptCallStack> m_callStack;
 };
 
 ExecutionContext::ExecutionContext()
-    : m_client(0)
-    , m_sandboxFlags(SandboxNone)
+    : m_sandboxFlags(SandboxNone)
     , m_circularSequentialID(0)
     , m_inDispatchErrorEvent(false)
     , m_activeDOMObjectsAreSuspended(false)
     , m_activeDOMObjectsAreStopped(false)
 {
 }
 
 ExecutionContext::~ExecutionContext()
 {
 }
@@ skipping 22 matching lines @@
 }
 
 unsigned ExecutionContext::activeDOMObjectCount()
 {
     return lifecycleNotifier().activeDOMObjects().size();
 }
 
 void ExecutionContext::suspendScheduledTasks()
 {
     suspendActiveDOMObjects();
-    if (m_client)
-        m_client->tasksWereSuspended();
+    tasksWereSuspended();
 }
 
 void ExecutionContext::resumeScheduledTasks()
 {
     resumeActiveDOMObjects();
-    if (m_client)
-        m_client->tasksWereResumed();
+    tasksWereResumed();
 }
 
 void ExecutionContext::suspendActiveDOMObjectIfNeeded(ActiveDOMObject* object)
 {
     ASSERT(lifecycleNotifier().contains(object));
     // Ensure all ActiveDOMObjects are suspended also newly created ones.
     if (m_activeDOMObjectsAreSuspended)
         object->suspend();
 }
 
 bool ExecutionContext::shouldSanitizeScriptError(const String& sourceURL, AccessControlStatus corsStatus)
 {
     return !(securityOrigin()->canRequest(completeURL(sourceURL)) || corsStatus == SharableCrossOrigin);
 }
 
 void ExecutionContext::reportException(PassRefPtrWillBeRawPtr<ErrorEvent> event, int scriptId, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack, AccessControlStatus corsStatus)
 {
     RefPtrWillBeRawPtr<ErrorEvent> errorEvent = event;
     if (m_inDispatchErrorEvent) {
         if (!m_pendingExceptions)
             m_pendingExceptions = adoptPtrWillBeNoop(new WillBeHeapVector<OwnPtrWillBeMember<PendingException> >());
         m_pendingExceptions->append(adoptPtrWillBeNoop(new PendingException(errorEvent->messageForConsole(), errorEvent->lineno(), errorEvent->colno(), scriptId, errorEvent->filename(), callStack)));
         return;
     }
 
     // First report the original exception and only then all the nested ones.
-    if (!dispatchErrorEvent(errorEvent, corsStatus) && m_client)
-        m_client->logExceptionToConsole(errorEvent->messageForConsole(), scriptId, errorEvent->filename(), errorEvent->lineno(), errorEvent->colno(), callStack);
+    if (!dispatchErrorEvent(errorEvent, corsStatus))
+        logExceptionToConsole(errorEvent->messageForConsole(), scriptId, errorEvent->filename(), errorEvent->lineno(), errorEvent->colno(), callStack);
 
     if (!m_pendingExceptions)
         return;
 
     for (size_t i = 0; i < m_pendingExceptions->size(); i++) {
         PendingException* e = m_pendingExceptions->at(i).get();
-        if (m_client)
-            m_client->logExceptionToConsole(e->m_errorMessage, e->m_scriptId, e->m_sourceURL, e->m_lineNumber, e->m_columnNumber, e->m_callStack);
+        logExceptionToConsole(e->m_errorMessage, e->m_scriptId, e->m_sourceURL, e->m_lineNumber, e->m_columnNumber, e->m_callStack);
     }
     m_pendingExceptions.clear();
 }
 
-void ExecutionContext::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
-{
-    if (!m_client)
-        return;
-    m_client->addMessage(consoleMessage);
-}
-
 bool ExecutionContext::dispatchErrorEvent(PassRefPtrWillBeRawPtr<ErrorEvent> event, AccessControlStatus corsStatus)
 {
-    if (!m_client)
-        return false;
-    EventTarget* target = m_client->errorEventTarget();
+    EventTarget* target = errorEventTarget();
     if (!target)
         return false;
 
     RefPtrWillBeRawPtr<ErrorEvent> errorEvent = event;
     if (shouldSanitizeScriptError(errorEvent->filename(), corsStatus))
         errorEvent = ErrorEvent::createSanitizedError(errorEvent->world());
 
     ASSERT(!m_inDispatchErrorEvent);
     m_inDispatchErrorEvent = true;
     target->dispatchEvent(errorEvent);
@@ skipping 39 matching lines @@
         m_publicURLManager = PublicURLManager::create(this);
     return *m_publicURLManager;
 }
 
 void ExecutionContext::didChangeTimerAlignmentInterval()
 {
     for (TimeoutMap::iterator iter = m_timeouts.begin(); iter != m_timeouts.end(); ++iter)
         iter->value->didChangeAlignmentInterval();
 }
 
-SecurityOrigin* ExecutionContext::securityOrigin() const
+SecurityOrigin* ExecutionContext::securityOrigin()
 {
-    RELEASE_ASSERT(m_client);
-    return m_client->securityContext().securityOrigin();
+    return securityContext().securityOrigin();
 }
 
-ContentSecurityPolicy* ExecutionContext::contentSecurityPolicy() const
+ContentSecurityPolicy* ExecutionContext::contentSecurityPolicy()
 {
-    RELEASE_ASSERT(m_client);
-    return m_client->securityContext().contentSecurityPolicy();
+    return securityContext().contentSecurityPolicy();
 }
 
 const KURL& ExecutionContext::url() const
 {
-    if (!m_client) {
-        DEFINE_STATIC_LOCAL(KURL, emptyURL, ());
-        return emptyURL;
-    }
-
     return virtualURL();
 }
 
 KURL ExecutionContext::completeURL(const String& url) const
 {
-
-    if (!m_client) {
-        DEFINE_STATIC_LOCAL(KURL, emptyURL, ());
-        return emptyURL;
-    }
-
     return virtualCompleteURL(url);
 }
 
-void ExecutionContext::disableEval(const String& errorMessage)
-{
-    if (!m_client)
-        return;
-    return m_client->disableEval(errorMessage);
-}
-
-LocalDOMWindow* ExecutionContext::executingWindow() const
-{
-    RELEASE_ASSERT(m_client);
-    return m_client->executingWindow();
-}
-
-String ExecutionContext::userAgent(const KURL& url) const
-{
-    if (!m_client)
-        return String();
-    return m_client->userAgent(url);
-}
-
-double ExecutionContext::timerAlignmentInterval() const
-{
-    if (!m_client)
-        return DOMTimer::visiblePageAlignmentInterval();
-    return m_client->timerAlignmentInterval();
-}
-
-void ExecutionContext::postTask(PassOwnPtr<ExecutionContextTask> task)
-{
-    if (!m_client)
-        return;
-    m_client->postTask(task);
-}
-
 PassOwnPtr<LifecycleNotifier<ExecutionContext> > ExecutionContext::createLifecycleNotifier()
 {
     return ContextLifecycleNotifier::create(this);
 }
 
 ContextLifecycleNotifier& ExecutionContext::lifecycleNotifier()
 {
     return static_cast<ContextLifecycleNotifier&>(LifecycleContext<ExecutionContext>::lifecycleNotifier());
 }
 
 bool ExecutionContext::isIteratingOverObservers() const
 {
     return m_lifecycleNotifier && m_lifecycleNotifier->isIteratingOverObservers();
 }
 
 void ExecutionContext::enforceSandboxFlags(SandboxFlags mask)
 {
     m_sandboxFlags |= mask;
 
-    RELEASE_ASSERT(m_client);
     // The SandboxOrigin is stored redundantly in the security origin.
-    if (isSandboxed(SandboxOrigin) && m_client->securityContext().securityOrigin() && !m_client->securityContext().securityOrigin()->isUnique()) {
-        m_client->securityContext().setSecurityOrigin(SecurityOrigin::createUnique());
-        m_client->didUpdateSecurityOrigin();
+    if (isSandboxed(SandboxOrigin) && securityContext().securityOrigin() && !securityContext().securityOrigin()->isUnique()) {
+        securityContext().setSecurityOrigin(SecurityOrigin::createUnique());
+        didUpdateSecurityOrigin();
     }
 }
 
 void ExecutionContext::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_pendingExceptions);
 #endif
     WillBeHeapSupplementable<ExecutionContext>::trace(visitor);
     LifecycleContext<ExecutionContext>::trace(visitor);
 }
 
 } // namespace blink