Move notification resource loading from content/child to blink

third_party/WebKit/Source/modules/notifications/Notification.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/ScopedWindowFocusAllowedIndicator.h"
 #include "core/events/Event.h"
 #include "core/frame/UseCounter.h"
 #include "modules/notifications/NotificationAction.h"
 #include "modules/notifications/NotificationData.h"
 #include "modules/notifications/NotificationOptions.h"
 #include "modules/notifications/NotificationPermissionClient.h"
+#include "modules/notifications/NotificationResourcesLoader.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebString.h"
 #include "public/platform/modules/notifications/WebNotificationAction.h"
 #include "public/platform/modules/notifications/WebNotificationManager.h"
+#include "wtf/Functional.h"
 
 namespace blink {
 namespace {
 
 const int64_t kInvalidPersistentId = -1;
 
 WebNotificationManager* notificationManager()
 {
     return Platform::current()->notificationManager();
 }
@@ skipping 29 matching lines @@
         UseCounter::count(context, UseCounter::NotificationInsecureOrigin);
         if (context->isDocument())
             UseCounter::countCrossOriginIframe(*toDocument(context),  UseCounter::NotificationAPIInsecureOriginIframe);
     }
 
     WebNotificationData data = createWebNotificationData(context, title, options, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     Notification* notification = new Notification(context, data);
-    notification->scheduleShow();
+    notification->schedulePrepareShow();
     notification->suspendIfNeeded();
 
     return notification;
 }
 
 Notification* Notification::create(ExecutionContext* context, int64_t persistentId, const WebNotificationData& data, bool showing)
 {
     Notification* notification = new Notification(context, data);
     notification->setPersistentId(persistentId);
     notification->setState(showing ? NotificationStateShowing : NotificationStateClosed);
     notification->suspendIfNeeded();
 
     return notification;
 }
 
 Notification::Notification(ExecutionContext* context, const WebNotificationData& data)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
     , m_data(data)
     , m_persistentId(kInvalidPersistentId)
     , m_state(NotificationStateIdle)
-    , m_asyncRunner(AsyncMethodRunner<Notification>::create(this, &Notification::show))
+    , m_prepareShowMethodRunner(AsyncMethodRunner<Notification>::create(this, &Notification::prepareShow))
 {
     ASSERT(notificationManager());
 }
 
 Notification::~Notification()
 {
 }
 
-void Notification::scheduleShow()
+void Notification::schedulePrepareShow()
 {
     ASSERT(m_state == NotificationStateIdle);
-    ASSERT(!m_asyncRunner->isActive());
+    ASSERT(!m_prepareShowMethodRunner->isActive());
 
-    m_asyncRunner->runAsync();
+    m_prepareShowMethodRunner->runAsync();
 }
 
-void Notification::show()
+void Notification::prepareShow()
 {
     ASSERT(m_state == NotificationStateIdle);
     if (Notification::checkPermission(getExecutionContext()) != WebNotificationPermissionAllowed) {
         dispatchErrorEvent();
         return;
     }
 
+    m_loader = new NotificationResourcesLoader(bind<NotificationResourcesLoader*>(&Notification::didLoadResources, WeakPersistentThisPointer<Notification>(this)));
+    m_loader->start(getExecutionContext(), m_data);
+}
+
+void Notification::didLoadResources(NotificationResourcesLoader* loader)
+{
+    DCHECK_EQ(loader, m_loader.get());
+
     SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
     ASSERT(origin);
 
-    notificationManager()->show(WebSecurityOrigin(origin), m_data, this);
+    notificationManager()->show(WebSecurityOrigin(origin), m_data, loader->getResources(), this);
+    m_loader.clear();
 
     m_state = NotificationStateShowing;
 }
 
 void Notification::close()
 {
     if (m_state != NotificationStateShowing)
         return;
 
     if (m_persistentId == kInvalidPersistentId) {
@@ skipping 216 matching lines @@
 {
     return EventTargetNames::Notification;
 }
 
 void Notification::stop()
 {
     notificationManager()->notifyDelegateDestroyed(this);
 
     m_state = NotificationStateClosed;
 
-    m_asyncRunner->stop();
+    m_prepareShowMethodRunner->stop();
+
+    if (m_loader)
+        m_loader->stop();
 }
 
 bool Notification::hasPendingActivity() const
 {
-    return m_state == NotificationStateShowing || m_asyncRunner->isActive();
+    return m_state == NotificationStateShowing || m_prepareShowMethodRunner->isActive() || m_loader;
 }
 
 DEFINE_TRACE(Notification)
 {
-    visitor->trace(m_asyncRunner);
+    visitor->trace(m_prepareShowMethodRunner);
+    visitor->trace(m_loader);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink