Move more classes to WebLocalFrameBase instead of WebLocalFrameImpl.

third_party/WebKit/Source/web/WebFrameSerializer.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 20 matching lines @@
 #include "public/web/WebFrameSerializer.h"
 
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/Frame.h"
 #include "core/frame/FrameSerializer.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
+#include "core/frame/WebLocalFrameBase.h"
 #include "core/html/HTMLAllCollection.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTableElement.h"
 #include "core/layout/LayoutBox.h"
 #include "core/loader/DocumentLoader.h"
 #include "platform/Histogram.h"
 #include "platform/SerializedResource.h"
@@ skipping 14 matching lines @@
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLResponse.h"
 #include "public/platform/WebVector.h"
 #include "public/web/WebDataSource.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebFrameSerializerCacheControlPolicy.h"
 #include "public/web/WebFrameSerializerClient.h"
 #include "web/WebFrameSerializerImpl.h"
-#include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 
 namespace blink {
 
 namespace {
 
 const int kPopupOverlayZIndexThreshold = 50;
 
 class MHTMLFrameSerializerDelegate final : public FrameSerializer::Delegate {
   WTF_MAKE_NONCOPYABLE(MHTMLFrameSerializerDelegate);
@@ skipping 237 matching lines @@
   // Disable all form elements in MTHML to tell the user that the form cannot be
   // worked on. MHTML is loaded in full sandboxing mode which disable the form
   // submission and script execution.
   if (element.FastHasAttribute(HTMLNames::disabledAttr))
     return;
   Attribute disabled_attribute(HTMLNames::disabledAttr, "");
   attributes->push_back(disabled_attribute);
 }
 
 bool CacheControlNoStoreHeaderPresent(
-    const WebLocalFrameImpl& web_local_frame_impl) {
+    const WebLocalFrameBase& web_local_frame) {
   const ResourceResponse& response =
-      web_local_frame_impl.DataSource()->GetResponse().ToResourceResponse();
+      web_local_frame.DataSource()->GetResponse().ToResourceResponse();
   if (response.CacheControlContainsNoStore())
     return true;
 
   const ResourceRequest& request =
-      web_local_frame_impl.DataSource()->GetRequest().ToResourceRequest();
+      web_local_frame.DataSource()->GetRequest().ToResourceRequest();
   return request.CacheControlContainsNoStore();
 }
 
 bool FrameShouldBeSerializedAsMHTML(
     WebLocalFrame* frame,
     WebFrameSerializerCacheControlPolicy cache_control_policy) {
-  WebLocalFrameImpl* web_local_frame_impl = ToWebLocalFrameImpl(frame);
-  DCHECK(web_local_frame_impl);
+  WebLocalFrameBase* web_local_frame = ToWebLocalFrameBase(frame);
+  DCHECK(web_local_frame);
 
   if (cache_control_policy == WebFrameSerializerCacheControlPolicy::kNone)
     return true;
 
   bool need_to_check_no_store =
       cache_control_policy == WebFrameSerializerCacheControlPolicy::
                                   kSkipAnyFrameOrResourceMarkedNoStore ||
       (!frame->Parent() &&
        cache_control_policy ==
            WebFrameSerializerCacheControlPolicy::kFailForNoStoreMainFrame);
 
   if (!need_to_check_no_store)
     return true;
 
-  return !CacheControlNoStoreHeaderPresent(*web_local_frame_impl);
+  return !CacheControlNoStoreHeaderPresent(*web_local_frame);
 }
 
 }  // namespace
 
 WebThreadSafeData WebFrameSerializer::GenerateMHTMLHeader(
     const WebString& boundary,
     WebLocalFrame* frame,
     MHTMLPartsGenerationDelegate* delegate) {
   TRACE_EVENT0("page-serialization", "WebFrameSerializer::generateMHTMLHeader");
   DCHECK(frame);
   DCHECK(delegate);
 
   if (!FrameShouldBeSerializedAsMHTML(frame, delegate->CacheControlPolicy()))
     return WebThreadSafeData();
 
-  WebLocalFrameImpl* web_local_frame_impl = ToWebLocalFrameImpl(frame);
-  DCHECK(web_local_frame_impl);
+  WebLocalFrameBase* web_local_frame = ToWebLocalFrameBase(frame);
+  DCHECK(web_local_frame);
 
-  Document* document = web_local_frame_impl->GetFrame()->GetDocument();
+  Document* document = web_local_frame->GetFrame()->GetDocument();
 
   RefPtr<RawData> buffer = RawData::Create();
   MHTMLArchive::GenerateMHTMLHeader(boundary, document->title(),
                                     document->SuggestedMIMEType(),
                                     *buffer->MutableData());
   return buffer.Release();
 }
 
 WebThreadSafeData WebFrameSerializer::GenerateMHTMLParts(
     const WebString& boundary,
     WebLocalFrame* web_frame,
     MHTMLPartsGenerationDelegate* web_delegate) {
   TRACE_EVENT0("page-serialization", "WebFrameSerializer::generateMHTMLParts");
   DCHECK(web_frame);
   DCHECK(web_delegate);
 
   if (!FrameShouldBeSerializedAsMHTML(web_frame,
                                       web_delegate->CacheControlPolicy()))
     return WebThreadSafeData();
 
   // Translate arguments from public to internal blink APIs.
-  LocalFrame* frame = ToWebLocalFrameImpl(web_frame)->GetFrame();
+  LocalFrame* frame = ToWebLocalFrameBase(web_frame)->GetFrame();
   MHTMLArchive::EncodingPolicy encoding_policy =
       web_delegate->UseBinaryEncoding()
           ? MHTMLArchive::EncodingPolicy::kUseBinaryEncoding
           : MHTMLArchive::EncodingPolicy::kUseDefaultEncoding;
 
   // Serialize.
   TRACE_EVENT_BEGIN0("page-serialization",
                      "WebFrameSerializer::generateMHTMLParts serializing");
   Deque<SerializedResource> resources;
   {
@@ skipping 64 matching lines @@
     const WebString& base_target) {
   // TODO(yosin) We should call |FrameSerializer::baseTagDeclarationOf()|.
   if (base_target.IsEmpty())
     return String("<base href=\".\">");
   String base_string = "<base href=\".\" target=\"" +
                        static_cast<const String&>(base_target) + "\">";
   return base_string;
 }
 
 }  // namespace blink