Rename WebFrameImpl to WebLocalFrameImpl.

Source/web/WebPageSerializerImpl.cpp

 /*
  * Copyright (C) 2009 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 61 matching lines @@
 // know those old base tags are original content or added by JavaScript. If
 // they are added by JavaScript, it means when loading saved page, the script(s)
 // will still insert base tag(s) to DOM, so the new added base tag(s) can
 // override the incorrect base URL and make sure we alway load correct local
 // saved resource files.
 
 #include "config.h"
 #include "WebPageSerializerImpl.h"
 
 #include "HTMLNames.h"
-#include "WebFrameImpl.h"
+#include "WebLocalFrameImpl.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/editing/markup.h"
 #include "core/html/HTMLAllCollection.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/loader/DocumentLoader.h"
@@ skipping 222 matching lines @@
 
                 // Check whether we need to replace some resource links
                 // with local resource paths.
                 const QualifiedName& attrName = attribute.name();
                 if (element->hasLegalLinkAttribute(attrName)) {
                     // For links start with "javascript:", we do not change it.
                     if (attrValue.startsWith("javascript:", false))
                         result.append(attrValue);
                     else {
                         // Get the absolute link
-                        WebFrameImpl* subFrame = WebFrameImpl::fromFrameOwnerElement(element);
+                        WebLocalFrameImpl* subFrame = WebLocalFrameImpl::fromFrameOwnerElement(element);
                         String completeURL = subFrame ? subFrame->frame()->document()->url() :
                                                         param->document->completeURL(attrValue);
                         // Check whether we have local files for those link.
                         if (m_localLinks.contains(completeURL)) {
                             if (!param->directoryName.isEmpty()) {
                                 result.appendLiteral("./");
                                 result.append(param->directoryName);
                                 result.append('/');
                             }
                             result.append(m_localLinks.get(completeURL));
@@ skipping 99 matching lines @@
                                              const WebString& localDirectoryName)
     : m_client(client)
     , m_recursiveSerialization(recursiveSerialization)
     , m_framesCollected(false)
     , m_localDirectoryName(localDirectoryName)
     , m_htmlEntities(false)
     , m_xmlEntities(true)
 {
     // Must specify available webframe.
     ASSERT(frame);
-    m_specifiedWebFrameImpl = toWebFrameImpl(frame);
+    m_specifiedWebLocalFrameImpl = toWebLocalFrameImpl(frame);
     // Make sure we have non 0 client.
     ASSERT(client);
     // Build local resources map.
     ASSERT(links.size() == localPaths.size());
     for (size_t i = 0; i < links.size(); i++) {
         KURL url = links[i];
         ASSERT(!m_localLinks.contains(url.string()));
         m_localLinks.set(url.string(), localPaths[i]);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
 }
 
 void WebPageSerializerImpl::collectTargetFrames()
 {
     ASSERT(!m_framesCollected);
     m_framesCollected = true;
 
     // First, process main frame.
-    m_frames.append(m_specifiedWebFrameImpl);
+    m_frames.append(m_specifiedWebLocalFrameImpl);
     // Return now if user only needs to serialize specified frame, not including
     // all sub-frames.
     if (!m_recursiveSerialization)
         return;
     // Collect all frames inside the specified frame.
     for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) {
-        WebFrameImpl* currentFrame = m_frames[i];
+        WebLocalFrameImpl* currentFrame = m_frames[i];
         // Get current using document.
         Document* currentDoc = currentFrame->frame()->document();
         // Go through sub-frames.
         RefPtr<HTMLCollection> all = currentDoc->all();
 
         for (unsigned i = 0; Element* element = all->item(i); i++) {
             if (!element->isHTMLElement())
                 continue;
-            WebFrameImpl* webFrame =
-                WebFrameImpl::fromFrameOwnerElement(element);
+            WebLocalFrameImpl* webFrame =
+                WebLocalFrameImpl::fromFrameOwnerElement(element);
             if (webFrame)
                 m_frames.append(webFrame);
         }
     }
 }
 
 bool WebPageSerializerImpl::serialize()
 {
     if (!m_framesCollected)
         collectTargetFrames();
 
     bool didSerialization = false;
-    KURL mainURL = m_specifiedWebFrameImpl->frame()->document()->url();
+    KURL mainURL = m_specifiedWebLocalFrameImpl->frame()->document()->url();
 
     for (unsigned i = 0; i < m_frames.size(); ++i) {
-        WebFrameImpl* webFrame = m_frames[i];
+        WebLocalFrameImpl* webFrame = m_frames[i];
         Document* document = webFrame->frame()->document();
         const KURL& url = document->url();
 
         if (!url.isValid() || !m_localLinks.contains(url.string()))
             continue;
 
         didSerialization = true;
 
         const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
         String directoryName = url == mainURL ? m_localDirectoryName : "";
 
         SerializeDomParam param(url, textEncoding, document, directoryName);
 
         Element* documentElement = document->documentElement();
         if (documentElement)
             buildContentForNode(documentElement, &param);
 
         encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, &param, ForceFlush);
     }
 
     ASSERT(m_dataBuffer.isEmpty());
     m_client->didSerializeDataForFrame(KURL(), WebCString("", 0), WebPageSerializerClient::AllFramesAreFinished);
     return didSerialization;
 }
 
 }  // namespace blink