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 <map>
 #include <queue>
 #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"
@@ skipping 164 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();
 
   // Ask renderer processes to serialize all frames in the current page.
+  // (serialize into html data with "blanks" that we can replace with links to
+  // local paths).
   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.
-  // The parameter |saved_file_paths| contains corresponding local file paths of
-  // all saved links, which is matched with vector:links 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(int frame_tree_node_id);
 
   // 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 52 matching lines @@
 
   // 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;
   // 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_;
-
-  // Temporarily stores urls of savable frames, until we can process them.
-  std::vector<GURL> frame_urls_to_save_;
+  // Used to
+  // 1) de-dupe urls that are being gathered into |waiting_item_queue_|
+  // 2) find a SaveItem which needs to be updated with frame_tree_node_id or
+  //    referrer.
+  std::map<GURL, SaveItem*> url_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_