Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/resource_requester_info.cc

+// 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/10 08:17:57]

Do we really need all these subclasses?

[horo, 2016/11/10 14:46:33]

I think making subclasses for each purpose is easier to understand than adding
"if(RENDERER){} else if(BROWSER_SIDE_NAVIGATION) {} else {}" for each methods.

[kinuko, 2016/11/14 07:04:13]

I imagined this class could be a mere collection of necessary data fields that
can be initialized differently for each type.  (Probably the class name 'info'
made me expect that)

+ 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 child_id() const override { return child_id_; }
+  BrowserMessageFilter* filter() const override { return filter_.get(); }
+
+  void GetContexts(ResourceType resource_type,
+                   ResourceContext** resource_context,
+                   net::URLRequestContext** request_context) const override {
+    DCHECK(filter());
+    filter_->GetContexts(resource_type, resource_context, request_context);
+  }
+
+  ChromeAppCacheService* appcache_service() const override {
+    DCHECK(filter());
+    return filter_->appcache_service();
+  }
+
+  ChromeBlobStorageContext* blob_storage_context() const override {
+    DCHECK(filter());
+    return filter_->blob_storage_context();
+  }
+
+  storage::FileSystemContext* file_system_context() const override {
+    DCHECK(filter());
+    return filter_->file_system_context();
+  }
+
+  ServiceWorkerContextWrapper* service_worker_context() const override {
+    DCHECK(filter());
+    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 child_id() const override { return -1; }
+
+  BrowserMessageFilter* filter() 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 child_id() const override { return child_id_; }
+
+  BrowserMessageFilter* filter() 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(
+    base::WeakPtr<ResourceMessageFilter> filter) {
+  DCHECK(filter);
+  return base::MakeUnique<ResourceRequesterInfoForRenderer>(filter,
+                                                            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);
+}
+
+}  // namespace content