ABANDONED: OOPIFs: Moving stitching of local paths from renderer to browser process.

content/browser/download/save_package.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 #define CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 
-#include <queue>
+#include <deque>
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 25 matching lines @@
 // page as complete-html page means we save not only the main html file the user
 // told it to save but also a directory for the auxiliary files such as all
 // sub-frame html files, image files, css files and js files.  Saving page as
 // MHTML means the same thing as complete-html, but it uses the MHTML format to
 // contain the html and all auxiliary files in a single text file.
 //
 // Each page saving job may include one or multiple files which need to be
 // saved. Each file is represented by a SaveItem, and all SaveItems are owned
 // by the SavePackage. SaveItems are created when a user initiates a page
 // saving job, and exist for the duration of one contents's life time.
+// SaveItems go through waiting_item_queue_, in_progress_items_ and finally
+// end up either in saved_success_items_ or saved_failed_items_.
 class CONTENT_EXPORT SavePackage
     : public base::RefCountedThreadSafe<SavePackage>,
       public WebContentsObserver,
       public DownloadItem::Observer,
       public base::SupportsWeakPtr<SavePackage> {
  public:
   enum WaitState {
     // State when created but not initialized.
     INITIALIZE = 0,
     // State when after initializing, but not yet saving.
@@ skipping 118 matching lines @@
   void GetSavableResourceLinksForFrame(RenderFrameHost* target);
   void OnSavableResourceLinksResponse(
       RenderFrameHost* sender,
       const GURL& frame_url,
       const std::vector<GURL>& resources_list,
       const std::vector<Referrer>& referrers_list);
   void OnSavableResourceLinksError(RenderFrameHost* sender);
   void CompleteSavableResourceLinksResponse();
 
   // For each frame in the current page, ask the renderer process associated
-  // with that frame to serialize that frame into html.
+  // with that frame to serialize that frame into html (serialize into html with
+  // "blanks" that we can replace with links to local paths).

[ncarter (slow), 2015/10/08 20:57:55]

Make this parenthetical clause its own sentence, something like: Links will be
represented as "blanks", which we'll replace with local paths later.

Also: is "blanks" the right term to use? I don't see it used anywhere else in
save_package.cc.

[Łukasz Anforowicz, 2015/10/09 16:54:08]

I guess this comment is confusing (I have a feeling that you might have
misunderstood what it was trying to say - there are no actual blanks in the
serialized html - there are just OnSerializedLocalPathForFoo callbacks).  I
think removing the parenthetical clause is the best thing to do.

   void GetSerializedHtmlWithLocalLinks();
 
-  // Ask renderer process to serialize |target| frame into html data
-  // with lists which contain all resource links that have a local copy.
-  // - The parameter |saved_links| contains original URLs of all saved links
-  //   (which may include URLs referred to from the whole page (not just from
-  //   the |target| frame).
-  // - The parameter |saved_file_paths| contains corresponding local file paths
-  //   of all saved links, which is matched with |saved_links| vector one by
-  //   one.
-  // - The parameter |relative_dir_name| is relative path of directory which
-  //   contain all saved auxiliary files included all sub frames and resouces.
-  void GetSerializedHtmlWithLocalLinksForFrame(
-      const std::vector<GURL>& saved_links,
-      const std::vector<base::FilePath>& saved_file_paths,
-      const base::FilePath& relative_dir_name,
-      RenderFrameHost* target);
+  // Equivalent of GetSerializedHtmlWithLocalLinks that targets a single
+  // |target| frame.
+  void GetSerializedHtmlWithLocalLinksForFrame(RenderFrameHost* target);
 
-  // Routes html data (sent by renderer process in response to
-  // GetSerializedHtmlWithLocalLinksForFrame above) to the associated local file
-  // (and also keeps track of when all frames have been completed).
-  void OnSerializedHtmlWithLocalLinksResponse(RenderFrameHost* sender,
-                                              const GURL& frame_url,
-                                              const std::string& data,
-                                              int32 status);
+  // Response to GetSerializedHtmlWithLocalLinksForFrame above that routes html
+  // fragment into the local file associated with |sender|.
+  void OnSerializedHtmlFragment(RenderFrameHost* sender,
+                                const std::string& data);
+
+  // Response to GetSerializedHtmlWithLocalLinksForFrame above that replaces
+  // |render_frame_or_proxy_routing_id| with a corresponding local path
+  // and then writes the result to the local file associated with |sender|.
+  void OnSerializedLocalPathForSubFrame(RenderFrameHost* sender,
+                                        int render_frame_or_proxy_routing_id);
+
+  // Response to GetSerializedHtmlWithLocalLinksForFrame above that replaces
+  // |savable_resource| with a corresponding local path and then writes the
+  // result to the local file associated with |sender|.
+  void OnSerializedLocalPathForSavableResource(RenderFrameHost* sender,
+                                               const GURL& savable_resource);
+
+  // Response to GetSerializedHtmlWithLocalLinksForFrame above that keeps track
+  // of how many frames still need to complete their serialization process.
+  void OnSerializedEndOfFrame(RenderFrameHost* sender);
+
+  // Helper used by OnSerializedLocalPathForSubFrame and
+  // OnSerializedLocalPathForSavableResource to convert |save_item| into a local
+  // path (and falling back to |fallback_url| if |save_item| is null).
+  void SerializeLocalPathForSaveItem(RenderFrameHost* sender,
+                                     SaveItem* save_item,
+                                     const GURL& fallback_url);
+
+  // Finds in-progress SaveItem by |frame_tree_node_id|.
+  SaveItem* FindInProgressSaveItemByFrameTreeNodeID(int frame_tree_node_id);
+
+  // Helper to log telemetry entry for writes to already completed or failed
+  // SaveItems.
+  void LogWriteToAlreadyCompletedOrFailedSaveItem(SaveItem* save_item);
 
   // Look up SaveItem by save id from in progress map.
   SaveItem* LookupItemInProcessBySaveId(int32 save_id);
 
   // Remove SaveItem from in progress map and put it to saved map.
   void PutInProgressItemToSavedMap(SaveItem* save_item);
 
   // Retrieves the URL to be saved from the WebContents.
   GURL GetUrlToBeSaved();
 
@@ skipping 48 matching lines @@
   // Ensures that the file name has a proper extension for supported formats
   // if necessary.
   static base::FilePath EnsureMimeExtension(const base::FilePath& name,
       const std::string& contents_mime_type);
 
   // Returns extension for supported MIME types (for example, for "text/plain"
   // it returns "txt").
   static const base::FilePath::CharType* ExtensionForMimeType(
       const std::string& contents_mime_type);
 
-  typedef std::queue<SaveItem*> SaveItemQueue;
+  typedef std::deque<SaveItem*> SaveItemQueue;
   // A queue for items we are about to start saving.
   SaveItemQueue waiting_item_queue_;
 
-  // Used to de-dupe urls that are being gathered into |waiting_item_queue_|.
-  std::set<GURL> unique_urls_to_save_;
+  // Used to
+  // 1) de-dupe urls that are being gathered via GetSavableResourceLinks,
+  // 2) find a SaveItem which needs to be updated with frame_tree_node_id or
+  //    referrer,
+  // 3) find local path for savable resource.
+  // Note that |url_to_save_item_| does NOT own SaveItems - they remain owned
+  // by waiting_item_queue_, in_progress_items_, saved_success_items_, etc.
+  std::map<GURL, SaveItem*> url_to_save_item_;
 
-  // Temporarily stores urls of savable frames, until we can process them.
-  std::vector<GURL> frame_urls_to_save_;
+  // Used to find local path for a subframe.
+  // Note that |frame_tree_node_id_to_save_item_| does NOT own SaveItems - they
+  // remain owned by waiting_item_queue_, in_progress_items_, etc.
+  std::map<int, SaveItem*> frame_tree_node_id_to_save_item_;
 
   // Number of frames that we still need to get a response from.
   int number_of_frames_pending_response_;
 
   typedef base::hash_map<int32, SaveItem*> SavedItemMap;
   // saved_success_items_ is map of all saving job which are successfully saved.
   SavedItemMap saved_success_items_;
 
   // Non-owning pointer for handling file writing on the file thread.
   SaveFileManager* file_manager_;
@@ skipping 61 matching lines @@
   friend class SavePackageTest;
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestSuggestedSaveNames);
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestLongSafePureFilename);
 
   DISALLOW_COPY_AND_ASSIGN(SavePackage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_