Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/resource_requester_info.cc

Index: content/browser/loader/resource_requester_info.cc
diff --git a/content/browser/loader/resource_requester_info.cc b/content/browser/loader/resource_requester_info.cc
new file mode 100644
index 0000000000000000000000000000000000000000..659938d3ceb0553f2bec32799dd27cb594040dab
--- /dev/null
+++ b/content/browser/loader/resource_requester_info.cc
@@ -0,0 +1,204 @@
+// Copyright 2016 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/browser/loader/resource_requester_info.h"
+
+#include "base/memory/ptr_util.h"
+#include "content/browser/loader/resource_message_filter.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/public/browser/resource_context.h"
+#include "content/public/common/process_type.h"
+
+namespace content {
+
+namespace {
+
+class ResourceRequesterInfoForRenderer : public ResourceRequesterInfo {

[kinuko, 2016/11/14 16:29:41]

(Again) I think we could also make it a simple data-type class that just
initializes all necessary member fields when we create an instance without
making subclasses.  And for renderer cases we could just remove duplicated
member fields from RMF... would that work / make some sense to you or not?

[horo, 2016/11/17 11:57:06]

Done.

+ public:
+  explicit ResourceRequesterInfoForRenderer(
+      base::WeakPtr<ResourceMessageFilter> filter,
+      int child_id)
+      : filter_(filter), child_id_(child_id) {}
+
+  ~ResourceRequesterInfoForRenderer() override {}
+
+  std::unique_ptr<ResourceRequesterInfo> clone() const override {
+    return base::MakeUnique<ResourceRequesterInfoForRenderer>(filter_,
+                                                              child_id_);
+  }
+
+  bool IsRenderer() const override { return true; }
+  bool IsBrowserSideNavigation() const override { return false; }
+  int GetChildID() const override { return child_id_; }
+  BrowserMessageFilter* GetFilter() const override { return filter_.get(); }
+
+  void GetContexts(ResourceType resource_type,
+                   ResourceContext** resource_context,
+                   net::URLRequestContext** request_context) const override {
+    DCHECK(GetFilter());
+    filter_->GetContexts(resource_type, resource_context, request_context);
+  }
+
+  ChromeAppCacheService* appcache_service() const override {
+    DCHECK(GetFilter());
+    return filter_->appcache_service();
+  }
+
+  ChromeBlobStorageContext* blob_storage_context() const override {
+    DCHECK(GetFilter());
+    return filter_->blob_storage_context();
+  }
+
+  storage::FileSystemContext* file_system_context() const override {
+    DCHECK(GetFilter());
+    return filter_->file_system_context();
+  }
+
+  ServiceWorkerContextWrapper* service_worker_context() const override {
+    DCHECK(GetFilter());
+    return filter_->service_worker_context();
+  }
+
+ private:
+  // The filter might be deleted if the process exited.
+  const base::WeakPtr<ResourceMessageFilter> filter_;
+  const int child_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceRequesterInfoForRenderer);
+};
+
+class ResourceRequesterInfoForBrowserSideNavigation
+    : public ResourceRequesterInfo {
+ public:
+  explicit ResourceRequesterInfoForBrowserSideNavigation(
+      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
+      : service_worker_context_(std::move(service_worker_context)) {}
+  ~ResourceRequesterInfoForBrowserSideNavigation() override {}
+
+  std::unique_ptr<ResourceRequesterInfo> clone() const override {
+    return base::MakeUnique<ResourceRequesterInfoForBrowserSideNavigation>(
+        service_worker_context_);
+  }
+
+  bool IsRenderer() const override { return false; }
+  bool IsBrowserSideNavigation() const override { return true; }
+  int GetChildID() const override { return -1; }
+
+  BrowserMessageFilter* GetFilter() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  void GetContexts(ResourceType resource_type,
+                   ResourceContext** resource_context,
+                   net::URLRequestContext** request_context) const override {
+    NOTREACHED();
+  }
+
+  ChromeAppCacheService* appcache_service() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  ChromeBlobStorageContext* blob_storage_context() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  storage::FileSystemContext* file_system_context() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  ServiceWorkerContextWrapper* service_worker_context() const override {
+    return service_worker_context_.get();
+  }
+
+ private:
+  const scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceRequesterInfoForBrowserSideNavigation);
+};
+
+class ResourceRequesterInfoForDownloadOrPageSave
+    : public ResourceRequesterInfo {
+ public:
+  explicit ResourceRequesterInfoForDownloadOrPageSave(int child_id)
+      : child_id_(child_id) {}
+  ~ResourceRequesterInfoForDownloadOrPageSave() override {}
+
+  std::unique_ptr<ResourceRequesterInfo> clone() const override {
+    return base::MakeUnique<ResourceRequesterInfoForDownloadOrPageSave>(
+        child_id_);
+  }
+
+  bool IsRenderer() const override { return false; }
+  bool IsBrowserSideNavigation() const override { return false; }
+  int GetChildID() const override { return child_id_; }
+
+  BrowserMessageFilter* GetFilter() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  void GetContexts(ResourceType resource_type,
+                   ResourceContext** resource_context,
+                   net::URLRequestContext** request_context) const override {
+    NOTREACHED();
+  }
+
+  ChromeAppCacheService* appcache_service() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  ChromeBlobStorageContext* blob_storage_context() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  storage::FileSystemContext* file_system_context() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  ServiceWorkerContextWrapper* service_worker_context() const override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+ private:
+  const int child_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceRequesterInfoForDownloadOrPageSave);
+};
+
+}  // namespace
+
+std::unique_ptr<ResourceRequesterInfo> ResourceRequesterInfo::CreateForRenderer(
+    ResourceMessageFilter* filter) {
+  DCHECK(filter);
+  return base::MakeUnique<ResourceRequesterInfoForRenderer>(
+      filter->GetWeakPtr(), filter->child_id());
+}
+
+std::unique_ptr<ResourceRequesterInfo>
+ResourceRequesterInfo::CreateForRendererTesting(int child_id) {
+  return base::MakeUnique<ResourceRequesterInfoForRenderer>(
+      base::WeakPtr<ResourceMessageFilter>(), child_id);
+}
+
+std::unique_ptr<ResourceRequesterInfo>
+ResourceRequesterInfo::CreateForBrowserSideNavigation(
+    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context) {
+  return base::MakeUnique<ResourceRequesterInfoForBrowserSideNavigation>(
+      std::move(service_worker_context));
+}
+
+std::unique_ptr<ResourceRequesterInfo>
+ResourceRequesterInfo::CreateForDownloadOrPageSave(int child_id) {
+  return base::MakeUnique<ResourceRequesterInfoForDownloadOrPageSave>(child_id);

[kinuko, 2016/11/14 16:29:41]

Will we need to access service worker context for download cases?  How do you
plan to get that?  Will we retrieve it via RPH with UI thread hop without using
service_worker_context() field of this class?

[horo, 2016/11/17 11:57:06]

I don't fully understand the download behavior yet.
But DownloadManagerImpl lives on UI thread.
So we can get the service worker context in DownloadManagerImpl without adding
another thread hop.
Created a POC patch:
https://codereview.chromium.org/2498193003/#ps60001
https://codereview.chromium.org/2498193003/diff/60001/content/browser/downloa...

+}
+
+}  // namespace content