Don't reset LoadEventProgress if frame unload has already started.

third_party/WebKit/Source/core/html/HTMLFrameOwnerElement.h

 /*
  * Copyright (C) 2006, 2007, 2009 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 91 matching lines @@
     RawPtrWillBeMember<Frame> m_contentFrame;
     RefPtrWillBeMember<Widget> m_widget;
     SandboxFlags m_sandboxFlags;
 };
 
 DEFINE_ELEMENT_TYPE_CASTS(HTMLFrameOwnerElement, isFrameOwnerElement());
 
 class SubframeLoadingDisabler {
     STACK_ALLOCATED();
 public:
-    explicit SubframeLoadingDisabler(Node& root)
+    explicit SubframeLoadingDisabler(Node& root) : SubframeLoadingDisabler(&root)
+    {
+    }
+
+    explicit SubframeLoadingDisabler(Node* root)

[Nate Chapin, 2016/02/03 23:25:14]

Do we have to have constructors for both a pointer and a reference? That seems
kind of lame.

[dcheng, 2016/02/03 23:33:31]

A pre-Oilpan alternative is to just keep the reference constructor. Then we
could do something like:

OwnPtr<SubframeLoadingDisabler> disabler;
if (m_frame->document())
  disabler.reset(new SubframeLoadingDisabler(*m_frame->document()));

But this doesn't work with Oilpan: SubframeLoadingDisabler would have to become
a garbage collected class, but then it references a garbage collected member in
the destructor, and all sorts of complexity.

I just added the pointer version because it is still nice to assert that the
passed in Node* is not null (which is true 99% of the time).

An alternative (which I want to try following up on) is to rearrange
prepareForCommit() to make it so we only take this branch if document is not
null, but that's a bigger change and harder to merge.

         : m_root(root)
     {
-        disabledSubtreeRoots().add(m_root);
+        if (m_root)
+            disabledSubtreeRoots().add(m_root);
     }
 
     ~SubframeLoadingDisabler()
     {
-        disabledSubtreeRoots().remove(m_root);
+        if (m_root)
+            disabledSubtreeRoots().remove(m_root);
     }
 
     static bool canLoadFrame(HTMLFrameOwnerElement& owner)
     {
-        if (owner.document().unloadStarted())
-            return false;
         for (Node* node = &owner; node; node = node->parentOrShadowHostNode()) {
             if (disabledSubtreeRoots().contains(node))
                 return false;
         }
         return true;
     }
 
 private:
     static WillBeHeapHashCountedSet<RawPtrWillBeMember<Node>>& disabledSubtreeRoots();
 
     RawPtrWillBeMember<Node> m_root;
 };
 
 DEFINE_TYPE_CASTS(HTMLFrameOwnerElement, FrameOwner, owner, owner->isLocal(), owner.isLocal());
 
 } // namespace blink
 
 #endif // HTMLFrameOwnerElement_h