Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/resource_request_info_impl.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_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_
 #define CONTENT_BROWSER_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/supports_user_data.h"
-#include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/loader/resource_requester_info.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/public/browser/navigation_ui_data.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/resource_type.h"
 #include "net/base/load_states.h"
 
 namespace content {
 class DetachableResourceHandler;
 class ResourceContext;
 class ResourceMessageFilter;
 struct GlobalRequestID;
 struct GlobalRoutingID;
 
 // Holds the data ResourceDispatcherHost associates with each request.
 // Retrieve this data by calling ResourceDispatcherHost::InfoForRequest.
 class ResourceRequestInfoImpl : public ResourceRequestInfo,
                                 public base::SupportsUserData::Data {
  public:
   // Returns the ResourceRequestInfoImpl associated with the given URLRequest.
   CONTENT_EXPORT static ResourceRequestInfoImpl* ForRequest(
       net::URLRequest* request);
 
   // And, a const version for cases where you only need read access.
   CONTENT_EXPORT static const ResourceRequestInfoImpl* ForRequest(
       const net::URLRequest* request);
 
   CONTENT_EXPORT ResourceRequestInfoImpl(
-      int process_type,
-      int child_id,
+      std::unique_ptr<ResourceRequesterInfo> requester_info,
       int route_id,
       int frame_tree_node_id,
       int origin_pid,
       int request_id,
       int render_frame_id,
       bool is_main_frame,
       bool parent_is_main_frame,
       ResourceType resource_type,
       ui::PageTransition transition_type,
       bool should_replace_current_entry,
       bool is_download,
       bool is_stream,
       bool allow_download,
       bool has_user_gesture,
       bool enable_load_timing,
       bool enable_upload_progress,
       bool do_not_prompt_for_login,
       blink::WebReferrerPolicy referrer_policy,
       blink::WebPageVisibilityState visibility_state,
       ResourceContext* context,
-      base::WeakPtr<ResourceMessageFilter> filter,
       bool report_raw_headers,
       bool is_async,
       bool is_using_lofi,
       const std::string& original_headers,
       const scoped_refptr<ResourceRequestBodyImpl> body,
       bool initiated_in_secure_context);
   ~ResourceRequestInfoImpl() override;
 
   // ResourceRequestInfo implementation:
   WebContentsGetter GetWebContentsGetterForRequest() const override;
@@ skipping 24 matching lines @@
   CONTENT_EXPORT void AssociateWithRequest(net::URLRequest* request);
 
   CONTENT_EXPORT int GetRequestID() const;
   GlobalRoutingID GetGlobalRoutingID() const;
 
   // PlzNavigate
   // The id of the FrameTreeNode that initiated this request (for a navigation
   // request).
   int frame_tree_node_id() const { return frame_tree_node_id_; }
 
-  // May be NULL (e.g., if process dies during a transfer).
-  ResourceMessageFilter* filter() const {
-    return filter_.get();
+  const ResourceRequesterInfo& requester_info() const {
+    return *(requester_info_.get());

[mmenke, 2016/11/17 16:27:20]

nit:  Is the get actually needed?

[horo, 2016/11/17 17:50:27]

Done.

   }
 
   // Updates the data associated with this request after it is is transferred
   // to a new renderer process.  Not all data will change during a transfer.
   // We do not expect the ResourceContext to change during navigation, so that
   // does not need to be updated.
-  void UpdateForTransfer(int child_id,
-                         int route_id,
+  void UpdateForTransfer(int route_id,
                          int render_frame_id,
                          int origin_pid,
                          int request_id,
-                         base::WeakPtr<ResourceMessageFilter> filter);
+                         std::unique_ptr<ResourceRequesterInfo> requester_info);
 
   // Whether this request is part of a navigation that should replace the
   // current session history entry. This state is shuffled up and down the stack
   // for request transfers.
   bool should_replace_current_entry() const {
     return should_replace_current_entry_;
   }
 
   // DetachableResourceHandler for this request.  May be NULL.
   DetachableResourceHandler* detachable_handler() const {
     return detachable_handler_;
   }
   void set_detachable_handler(DetachableResourceHandler* h) {
     detachable_handler_ = h;
   }
 
-  // Identifies the type of process (renderer, plugin, etc.) making the request.
-  int process_type() const { return process_type_; }
-
   // Downloads are allowed only as a top level request.
   bool allow_download() const { return allow_download_; }
 
   // Whether this is a download.
   void set_is_download(bool download) { is_download_ = download; }
 
   // Whether this is a stream.
   bool is_stream() const { return is_stream_; }
   void set_is_stream(bool stream) { is_stream_ = stream; }
 
@@ skipping 34 matching lines @@
   }
   void set_initiated_in_secure_context_for_testing(bool secure) {
     initiated_in_secure_context_ = secure;
   }
 
   void set_navigation_ui_data(
       std::unique_ptr<NavigationUIData> navigation_ui_data) {
     navigation_ui_data_ = std::move(navigation_ui_data);
   }
 
-  // PlzNavigate: used in navigations to store the ServiceWorkerContext, since
-  // the ResourceMessageFilter will be null in this case. All other requests
-  // should access the ServiceWorkerContext through the ResourceMessageFilter.
-  void set_service_worker_context(
-      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context) {
-    service_worker_context_ = service_worker_context;
-  }
-  ServiceWorkerContextWrapper* service_worker_context() const {
-    return service_worker_context_.get();
-  }
-
  private:
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            DeletedFilterDetached);
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            DeletedFilterDetachedRedirect);
   // Non-owning, may be NULL.
   DetachableResourceHandler* detachable_handler_;
 
-  int process_type_;
-  int child_id_;
+  std::unique_ptr<ResourceRequesterInfo> requester_info_;
   int route_id_;
   const int frame_tree_node_id_;
   int origin_pid_;
   int request_id_;
   int render_frame_id_;
   bool is_main_frame_;
   bool parent_is_main_frame_;
   bool should_replace_current_entry_;
   bool is_download_;
   bool is_stream_;
   bool allow_download_;
   bool has_user_gesture_;
   bool enable_load_timing_;
   bool enable_upload_progress_;
   bool do_not_prompt_for_login_;
   bool was_ignored_by_handler_;
   bool counted_as_in_flight_request_;
   ResourceType resource_type_;
   ui::PageTransition transition_type_;
   int memory_cost_;
   blink::WebReferrerPolicy referrer_policy_;
   blink::WebPageVisibilityState visibility_state_;
   ResourceContext* context_;
-  // The filter might be deleted without deleting this object if the process
-  // exits during a transfer.
-  base::WeakPtr<ResourceMessageFilter> filter_;
   bool report_raw_headers_;
   bool is_async_;
   bool is_using_lofi_;
   const std::string original_headers_;
   scoped_refptr<ResourceRequestBodyImpl> body_;
   bool initiated_in_secure_context_;
   std::unique_ptr<NavigationUIData> navigation_ui_data_;
-  scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceRequestInfoImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_REQUEST_INFO_IMPL_H_