MHTMLTest::TestMHTMLEncoding checks generated MTHML is well formed.

third_party/WebKit/Source/web/tests/MHTMLTest.cpp

 /*
  * Copyright (C) 2014 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Location.h"
 #include "core/page/Page.h"
 #include "platform/SerializedResource.h"
 #include "platform/SharedBuffer.h"
 #include "platform/mhtml/MHTMLArchive.h"
+#include "platform/mhtml/MHTMLParser.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
@@ skipping 106 matching lines @@
 
     RefPtr<RawData> mhtml_data = RawData::Create();
     MHTMLArchive::GenerateMHTMLHeader(boundary, title, mime_type,
                                       *mhtml_data->MutableData());
     for (const auto& resource : resources) {
       MHTMLArchive::GenerateMHTMLPart(boundary, String(), encoding_policy,
                                       resource, *mhtml_data->MutableData());
     }
     MHTMLArchive::GenerateMHTMLFooterForTesting(boundary,
                                                 *mhtml_data->MutableData());
+
+    // Validate the generated MHTML.
+    MHTMLParser parser(
+        SharedBuffer::Create(mhtml_data->data(), mhtml_data->length()));
+    if (parser.ParseArchive().IsEmpty()) {
+      ADD_FAILURE() << "Invalid MHTML";
+      return RawData::Create();
+    }
+
     return mhtml_data.Release();
   }
 
   PassRefPtr<RawData> Serialize(const char* title,
                                 const char* mime,
                                 MHTMLArchive::EncodingPolicy encoding_policy) {
     return GenerateMHTMLData(resources_, encoding_policy, title, mime);
   }
 
  private:
@@ skipping 25 matching lines @@
   EXPECT_STREQ(kFileURL, frame->DomWindow()->location()->href().Ascii().data());
 
   SecurityOrigin* origin = document->GetSecurityOrigin();
   EXPECT_STRNE("localhost", origin->Domain().Ascii().data());
 }
 
 TEST_F(MHTMLTest, TestMHTMLEncoding) {
   AddTestResources();
   RefPtr<RawData> data = Serialize("Test Serialization", "text/html",
                                    MHTMLArchive::kUseDefaultEncoding);
+  ASSERT_FALSE(HasFailure());

[dcheng, 2017/04/26 08:52:39]

Per
https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuid...,
we should either just change Serialize() to use an out param (and use FAIL()) or
be content with a non-fatal assertion. It's a pretty unusual pattern to require
callers to check HasFailure(), as that means that this has to be duplicated
everywhere.

 
   // Read the MHTML data line per line and do some pseudo-parsing to make sure
   // the right encoding is used for the different sections.
   LineReader line_reader(std::string(data->data(), data->length()));
   int section_checked_count = 0;
   const char* expected_encoding = 0;
   std::string line;
   while (line_reader.GetNextLine(&line)) {
     if (line.compare(0, 13, "Content-Type:") == 0) {
       ASSERT_FALSE(expected_encoding);
@@ skipping 16 matching lines @@
       section_checked_count++;
     }
   }
   EXPECT_EQ(12, section_checked_count);
 }
 
 TEST_F(MHTMLTest, MHTMLFromScheme) {
   AddTestResources();
   RefPtr<RawData> raw_data = Serialize("Test Serialization", "text/html",
                                        MHTMLArchive::kUseDefaultEncoding);
+  ASSERT_FALSE(HasFailure());
+
   RefPtr<SharedBuffer> data =
       SharedBuffer::Create(raw_data->data(), raw_data->length());
   KURL http_url = ToKURL("http://www.example.com");
   KURL content_url = ToKURL("content://foo");
   KURL file_url = ToKURL("file://foo");
   KURL special_scheme_url = ToKURL("fooscheme://bar");
 
   // MHTMLArchives can only be initialized from local schemes, http/https
   // schemes, and content scheme(Android specific).
   EXPECT_NE(nullptr, MHTMLArchive::Create(http_url, data.Get()));
@@ skipping 24 matching lines @@
   // Full sandboxing should be turned on.
   EXPECT_TRUE(document->IsSandboxed(kSandboxAll));
 
   // MHTML document should be loaded into unique origin.
   EXPECT_TRUE(document->GetSecurityOrigin()->IsUnique());
   // Script execution should be disabled.
   EXPECT_FALSE(document->CanExecuteScripts(kNotAboutToExecuteScript));
 }
 
 }  // namespace blink