Phase III Step 2: Call imageNotifyFinished() and image load event after SVG loading completes

third_party/WebKit/Source/core/svg/graphics/SVGImage.cpp

 /*
  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. 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.
@@ skipping 47 matching lines @@
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintRecord.h"
 #include "platform/graphics/paint/PaintRecordBuilder.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/PassRefPtr.h"
 
 namespace blink {
 
+// SVGImageLocalFrameClient is used to wait until SVG document's load event
+// in the case where there are subresources asynchronously loaded.
+//
+// Reference cycle: SVGImage -(Persistent)-> Page -(Member)-> Frame -(Member)->
+// FrameClient == SVGImageLocalFrameClient -(raw)-> SVGImage.
+class SVGImage::SVGImageLocalFrameClient : public EmptyLocalFrameClient {
+ public:
+  SVGImageLocalFrameClient(SVGImage* image) : image_(image) {}
+
+  void ClearImage() { image_ = nullptr; }
+
+ private:
+  void DispatchDidHandleOnloadEvents() override {
+    // The SVGImage was destructed before SVG load completion.
+    if (!image_)
+      return;
+
+    image_->LoadCompleted();
+  }
+
+  // Cleared manually by SVGImage's destructor when |image_| is destructed.
+  SVGImage* image_;
+};
+
 SVGImage::SVGImage(ImageObserver* observer)
     : Image(observer),
       paint_controller_(PaintController::Create()),
       has_pending_timeline_rewind_(false) {}
 
 SVGImage::~SVGImage() {
+  if (frame_client_)
+    frame_client_->ClearImage();
+
   if (page_) {
     // Store m_page in a local variable, clearing m_page, so that
     // SVGImageChromeClient knows we're destructed.
     Page* current_page = page_.Release();
     // Break both the loader and view references to the frame
     current_page->WillBeDestroyed();
   }
 
   // Verify that page teardown destroyed the Chrome
   DCHECK(!chrome_client_ || !chrome_client_->GetImage());
@@ skipping 514 matching lines @@
 }
 
 void SVGImage::UpdateUseCounters(const Document& document) const {
   if (SVGSVGElement* root_element = SvgRootElement(page_.Get())) {
     if (root_element->TimeContainer()->HasAnimations())
       UseCounter::Count(document,
                         UseCounter::kSVGSMILAnimationInImageRegardlessOfCache);
   }
 }
 
+void SVGImage::LoadCompleted() {
+  switch (load_state_) {
+    case kInDataChanged:
+      load_state_ = kLoadCompleted;
+      break;
+
+    case kWaitingForAsyncLoadCompletion:
+      load_state_ = kLoadCompleted;
+      if (GetImageObserver())
+        GetImageObserver()->AsyncLoadCompleted(this);
+      break;
+
+    case kDataChangedNotStarted:
+    case kLoadCompleted:
+      CHECK(false);
+      break;
+  }
+}
+
 Image::SizeAvailability SVGImage::DataChanged(bool all_data_received) {
   TRACE_EVENT0("blink", "SVGImage::dataChanged");
 
   // Don't do anything if is an empty image.
   if (!Data()->size())
     return kSizeAvailable;
 
-  if (all_data_received) {
-    // SVGImage will fire events (and the default C++ handlers run) but doesn't
-    // actually allow script to run so it's fine to call into it. We allow this
-    // since it means an SVG data url can synchronously load like other image
-    // types.
-    EventDispatchForbiddenScope::AllowUserAgentEvents allow_user_agent_events;
+  if (!all_data_received)
+    return page_ ? kSizeAvailable : kSizeUnavailable;
 
-    DEFINE_STATIC_LOCAL(LocalFrameClient, dummy_local_frame_client,
-                        (EmptyLocalFrameClient::Create()));
+  CHECK(!page_);
 
-    CHECK(!page_);
+  // SVGImage will fire events (and the default C++ handlers run) but doesn't
+  // actually allow script to run so it's fine to call into it. We allow this
+  // since it means an SVG data url can synchronously load like other image
+  // types.
+  EventDispatchForbiddenScope::AllowUserAgentEvents allow_user_agent_events;
 
-    Page::PageClients page_clients;
-    FillWithEmptyClients(page_clients);
-    chrome_client_ = SVGImageChromeClient::Create(this);
-    page_clients.chrome_client = chrome_client_.Get();
+  CHECK_EQ(load_state_, kDataChangedNotStarted);
+  load_state_ = kInDataChanged;
 
-    // FIXME: If this SVG ends up loading itself, we might leak the world.
-    // The Cache code does not know about ImageResources holding Frames and
-    // won't know to break the cycle.
-    // This will become an issue when SVGImage will be able to load other
-    // SVGImage objects, but we're safe now, because SVGImage can only be
-    // loaded by a top-level document.
-    Page* page;
-    {
-      TRACE_EVENT0("blink", "SVGImage::dataChanged::createPage");
-      page = Page::Create(page_clients);
-      page->GetSettings().SetScriptEnabled(false);
-      page->GetSettings().SetPluginsEnabled(false);
-      page->GetSettings().SetAcceleratedCompositingEnabled(false);
+  Page::PageClients page_clients;
+  FillWithEmptyClients(page_clients);
+  chrome_client_ = SVGImageChromeClient::Create(this);
+  page_clients.chrome_client = chrome_client_.Get();
 
-      // Because this page is detached, it can't get default font settings
-      // from the embedder. Copy over font settings so we have sensible
-      // defaults. These settings are fixed and will not update if changed.
-      if (!Page::OrdinaryPages().IsEmpty()) {
-        Settings& default_settings =
-            (*Page::OrdinaryPages().begin())->GetSettings();
-        page->GetSettings().GetGenericFontFamilySettings() =
-            default_settings.GetGenericFontFamilySettings();
-        page->GetSettings().SetMinimumFontSize(
-            default_settings.GetMinimumFontSize());
-        page->GetSettings().SetMinimumLogicalFontSize(
-            default_settings.GetMinimumLogicalFontSize());
-        page->GetSettings().SetDefaultFontSize(
-            default_settings.GetDefaultFontSize());
-        page->GetSettings().SetDefaultFixedFontSize(
-            default_settings.GetDefaultFixedFontSize());
-      }
+  // FIXME: If this SVG ends up loading itself, we might leak the world.
+  // The Cache code does not know about ImageResources holding Frames and
+  // won't know to break the cycle.
+  // This will become an issue when SVGImage will be able to load other
+  // SVGImage objects, but we're safe now, because SVGImage can only be
+  // loaded by a top-level document.
+  Page* page;
+  {
+    TRACE_EVENT0("blink", "SVGImage::dataChanged::createPage");
+    page = Page::Create(page_clients);
+    page->GetSettings().SetScriptEnabled(false);
+    page->GetSettings().SetPluginsEnabled(false);
+    page->GetSettings().SetAcceleratedCompositingEnabled(false);
+
+    // Because this page is detached, it can't get default font settings
+    // from the embedder. Copy over font settings so we have sensible
+    // defaults. These settings are fixed and will not update if changed.
+    if (!Page::OrdinaryPages().IsEmpty()) {
+      Settings& default_settings =
+          (*Page::OrdinaryPages().begin())->GetSettings();
+      page->GetSettings().GetGenericFontFamilySettings() =
+          default_settings.GetGenericFontFamilySettings();
+      page->GetSettings().SetMinimumFontSize(
+          default_settings.GetMinimumFontSize());
+      page->GetSettings().SetMinimumLogicalFontSize(
+          default_settings.GetMinimumLogicalFontSize());
+      page->GetSettings().SetDefaultFontSize(
+          default_settings.GetDefaultFontSize());
+      page->GetSettings().SetDefaultFixedFontSize(
+          default_settings.GetDefaultFixedFontSize());
+    }
     }
 
     LocalFrame* frame = nullptr;
     {
       TRACE_EVENT0("blink", "SVGImage::dataChanged::createFrame");
-      frame = LocalFrame::Create(&dummy_local_frame_client, *page, 0);
+      DCHECK(!frame_client_);
+      frame_client_ = new SVGImageLocalFrameClient(this);
+      frame = LocalFrame::Create(frame_client_, *page, 0);
       frame->SetView(FrameView::Create(*frame));
       frame->Init();
     }
 
     FrameLoader& loader = frame->Loader();
     loader.ForceSandboxFlags(kSandboxAll);
 
     frame->View()->SetScrollbarsSuppressed(true);
     // SVG Images will always synthesize a viewBox, if it's not available, and
     // thus never see scrollbars.
     frame->View()->SetCanHaveScrollbars(false);
     // SVG Images are transparent.
     frame->View()->SetBaseBackgroundColor(Color::kTransparent);
 
     page_ = page;
 
     TRACE_EVENT0("blink", "SVGImage::dataChanged::load");
     loader.Load(FrameLoadRequest(
         0, ResourceRequest(BlankURL()),
         SubstituteData(Data(), AtomicString("image/svg+xml"),
                        AtomicString("UTF-8"), KURL(), kForceSynchronousLoad)));
 
     // Set the concrete object size before a container size is available.
     intrinsic_size_ = RoundedIntSize(ConcreteObjectSize(FloatSize(
         LayoutReplaced::kDefaultWidth, LayoutReplaced::kDefaultHeight)));
+
+    DCHECK(page_);
+    switch (load_state_) {
+      case kInDataChanged:
+        load_state_ = kWaitingForAsyncLoadCompletion;
+        return kSizeAvailableAndLoadingAsynchronously;
+
+      case kLoadCompleted:
+        return kSizeAvailable;
+
+      case kDataChangedNotStarted:
+      case kWaitingForAsyncLoadCompletion:
+        CHECK(false);
+        break;
   }
 
-  return page_ ? kSizeAvailable : kSizeUnavailable;
+  NOTREACHED();
+  return kSizeAvailable;
 }
 
 String SVGImage::FilenameExtension() const {
   return "svg";
 }
 
 }  // namespace blink