Introduces a new MHTML generation parameter specifying different behvaior for cache-control headers.

content/renderer/render_frame_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 51 matching lines @@
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/isolated_world_ids.h"
+#include "content/public/common/mhtml_generation.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/renderer/browser_plugin_delegate.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/context_menu_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame_observer.h"
@@ skipping 4810 matching lines @@
 
 void RenderFrameImpl::OnSerializeAsMHTML(
     const FrameMsg_SerializeAsMHTML_Params& params) {
   // Unpack IPC payload.
   base::File file = IPC::PlatformFileForTransitToFile(params.destination_file);
   const WebString mhtml_boundary =
       WebString::fromUTF8(params.mhtml_boundary_marker);
   DCHECK(!mhtml_boundary.isEmpty());
 
   WebData data;
-  bool success = true;
+  MHTMLSerializationResult result = MHTMLSerializationResult::OK;
   std::set<std::string> digests_of_uris_of_serialized_resources;
   MHTMLPartsGenerationDelegate delegate(
       params, &digests_of_uris_of_serialized_resources);
 
   // Generate MHTML header if needed.
   if (IsMainFrame()) {
-    data =
-        WebFrameSerializer::generateMHTMLHeader(mhtml_boundary, GetWebFrame());
-    if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
-      success = false;
+    bool success = WebFrameSerializer::generateMHTMLHeader(

[Łukasz Anforowicz, 2016/05/12 18:56:49]

Hmmm... conveying MHTMLSerializationResult::NO_STORE_MAIN_FRAME by a bool result
from WebFrameSerializer::generateMHTMLHeader seems wrong (especially given that
a comment for WebFrameSerializer::generateMHTMLHeader doesn't talk about this
semantics at all).

We could change the return type of WebFrameSerializer::generateMHTMLHeader from
bool to an enum, but maybe handling of FAIL_FOR_NO_STORE_MAIN_FRAME can simply
happen here (i.e. if we expose a new bool
WebLocalFrame::cacheControlContainsNoCache() method).  WDYT?

[dewittj, 2016/05/12 22:58:01]

Since I don't expose more granular errors any more, it doesn't make as much
sense to have an enum for this particular thing.  I returned bool as
success/fail - the only thing that currently makes it fail today is this cache
control header.

I updated the comment; does this look better to you now?

[Łukasz Anforowicz, 2016/05/12 23:56:27]

Yes - looks good.  Thanks.

+        mhtml_boundary,
+        mhtml::toCacheControlPolicy(params.mhtml_cache_control_policy),
+        GetWebFrame(), &data);
+    if (!success) {
+      result = MHTMLSerializationResult::NO_STORE_MAIN_FRAME;
+    } else if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
+      result = MHTMLSerializationResult::FILE_WRITE_FAILED_IN_HEADER;
     }
   }
 
   // Generate MHTML parts.
-  if (success) {
+  if (result == MHTMLSerializationResult::OK) {
     data = WebFrameSerializer::generateMHTMLParts(
         mhtml_boundary, GetWebFrame(), params.mhtml_binary_encoding, &delegate);
     // TODO(jcivelli): write the chunks in deferred tasks to give a chance to
     //                 the message loop to process other events.
-    if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
-      success = false;
-    }
+    if (file.WriteAtCurrentPos(data.data(), data.size()) < 0)
+      result = MHTMLSerializationResult::FILE_WRITE_FAILED_IN_PARTS_GEN;
   }
 
   // Generate MHTML footer if needed.
-  if (success && params.is_last_frame) {
+  if (result == MHTMLSerializationResult::OK && params.is_last_frame) {
     data = WebFrameSerializer::generateMHTMLFooter(mhtml_boundary);
-    if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
-      success = false;
-    }
+    if (file.WriteAtCurrentPos(data.data(), data.size()) < 0)
+      result = MHTMLSerializationResult::FILE_WRITE_FAILED_IN_FOOTER;
   }
 
   // Cleanup and notify the browser process about completion.
   file.Close();  // Need to flush file contents before sending IPC response.
   Send(new FrameHostMsg_SerializeAsMHTMLResponse(
-      routing_id_, params.job_id, success,
+      routing_id_, params.job_id, result,
       digests_of_uris_of_serialized_resources));
 }
 
 void RenderFrameImpl::OnFind(int request_id,
                              const base::string16& search_text,
                              const WebFindOptions& options) {
   // This should only be received on the main frame, since find-in-page is
   // currently orchestrated by the main frame.
   if (!is_main_frame_) {
     NOTREACHED();
@@ skipping 1078 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content