[bindings] Use explicit instantiation for OnLoadScriptInjectorHost

This change converts the OnLoadScriptInjectorHost template to use
explicit instantiation for std::string and uint64_t.  This will improve
compile times and also makes the types for ScriptId explicit.  The
change also fixes the public deps of the build target.

Bug: None
Change-Id: I0b52f7486589071150a6f5747daef0a0c6fceaa4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2468182
Commit-Queue: Brandon Tolsch <btolsch@chromium.org>
Reviewed-by: Kevin Marshall <kmarshall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#817587}

components/on_load_script_injector/browser/BUILD.gn

@@ -12,9 +12,13 @@ component("browser") {
 
   defines = [ "ON_LOAD_SCRIPT_INJECTOR_IMPLEMENTATION" ]
 
-  deps = [
+  public_deps = [
     "//base",
     "//components/on_load_script_injector:export",
+    "//url",
+  ]
+
+  deps = [
     "//components/on_load_script_injector:on_load_script_injector_mojom",
     "//content/public/browser",
     "//mojo/public/cpp/bindings",

components/on_load_script_injector/browser/on_load_script_injector_host.cc

@@ -6,6 +6,13 @@
 
 #include <utility>
 
+#include "base/numerics/safe_math.h"
+#include "base/strings/utf_string_conversions.h"
+#include "components/on_load_script_injector/on_load_script_injector.mojom.h"
+#include "content/public/browser/render_frame_host.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
+
 namespace on_load_script_injector {
 
 OriginScopedScript::OriginScopedScript() = default;
@@ -22,4 +29,104 @@ OriginScopedScript& OriginScopedScript::operator=(OriginScopedScript&& other) {
 
 OriginScopedScript::~OriginScopedScript() = default;
 
+template <typename ScriptId>
+OnLoadScriptInjectorHost<ScriptId>::OnLoadScriptInjectorHost() = default;
+template <typename ScriptId>
+OnLoadScriptInjectorHost<ScriptId>::~OnLoadScriptInjectorHost() = default;
+
+template <typename ScriptId>
+void OnLoadScriptInjectorHost<ScriptId>::AddScript(
+    ScriptId id,
+    std::vector<url::Origin> origins_to_inject,
+    base::StringPiece script) {
+  // If there is no script with the identifier |id|, then create a place for
+  // it at the end of the injection sequence.
+  if (before_load_scripts_.find(id) == before_load_scripts_.end())
+    before_load_scripts_order_.push_back(id);
+
+  // Convert script to UTF-16.
+  base::string16 script_utf16 = base::UTF8ToUTF16(script);
+  size_t script_utf16_size =
+      (base::CheckedNumeric<size_t>(script_utf16.size()) * sizeof(base::char16))
+          .ValueOrDie();
+  base::WritableSharedMemoryRegion script_shared_memory =
+      base::WritableSharedMemoryRegion::Create(script_utf16_size);
+  memcpy(script_shared_memory.Map().memory(), script_utf16.data(),
+         script_utf16_size);
+
+  base::ReadOnlySharedMemoryRegion script_shared_memory_readonly =
+      base::WritableSharedMemoryRegion::ConvertToReadOnly(
+          std::move(script_shared_memory));
+  CHECK(script_shared_memory_readonly.IsValid());
+
+  before_load_scripts_[id] = OriginScopedScript(
+      origins_to_inject, std::move(script_shared_memory_readonly));
+}
+
+template <typename ScriptId>
+void OnLoadScriptInjectorHost<ScriptId>::AddScriptForAllOrigins(
+    ScriptId id,
+    base::StringPiece script) {
+  AddScript(id, {kMatchAllOrigins}, script);
+}
+
+template <typename ScriptId>
+void OnLoadScriptInjectorHost<ScriptId>::RemoveScript(ScriptId id) {
+  before_load_scripts_.erase(id);
+
+  for (auto script_id_iter = before_load_scripts_order_.begin();
+       script_id_iter != before_load_scripts_order_.end(); ++script_id_iter) {
+    if (*script_id_iter == id) {
+      before_load_scripts_order_.erase(script_id_iter);
+      return;
+    }
+  }
+
+  LOG(WARNING) << "Ignoring attempt to remove unknown OnLoad script: " << id;
+}
+
+template <typename ScriptId>
+void OnLoadScriptInjectorHost<ScriptId>::InjectScriptsForURL(
+    const GURL& url,
+    content::RenderFrameHost* render_frame_host) {
+  DCHECK(url.is_valid());
+
+  mojo::AssociatedRemote<mojom::OnLoadScriptInjector> injector;
+  render_frame_host->GetRemoteAssociatedInterfaces()->GetInterface(&injector);
+
+  injector->ClearOnLoadScripts();
+
+  if (before_load_scripts_.empty())
+    return;
+
+  // Provision the renderer's ScriptInjector with the scripts associated with
+  // |url|.
+  for (ScriptId script_id : before_load_scripts_order_) {
+    const OriginScopedScript& script = before_load_scripts_[script_id];
+    if (IsUrlMatchedByOriginList(url, script.origins()))
+      injector->AddOnLoadScript(script.script().Duplicate());
+  }
+}
+
+template <typename ScriptId>
+bool OnLoadScriptInjectorHost<ScriptId>::IsUrlMatchedByOriginList(
+    const GURL& url,
+    const std::vector<url::Origin>& allowed_origins) {
+  url::Origin url_origin = url::Origin::Create(url);
+
+  for (const url::Origin& allowed_origin : allowed_origins) {
+    if (allowed_origin == kMatchAllOrigins)
+      return true;
+
+    DCHECK(!allowed_origin.opaque());
+    if (url_origin.IsSameOriginWith(allowed_origin))
+      return true;
+  }
+
+  return false;
+}
+
+template class OnLoadScriptInjectorHost<std::string>;
+template class OnLoadScriptInjectorHost<uint64_t>;
+
 }  // namespace on_load_script_injector

components/on_load_script_injector/browser/on_load_script_injector_host.h

@@ -10,17 +10,13 @@
 #include <vector>
 
 #include "base/memory/read_only_shared_memory_region.h"
-#include "base/numerics/safe_math.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build/build_config.h"
 #include "components/on_load_script_injector/export.h"
-#include "components/on_load_script_injector/on_load_script_injector.mojom.h"
-#include "content/public/browser/navigation_handle.h"
-#include "content/public/browser/render_frame_host.h"
-#include "mojo/public/cpp/bindings/associated_remote.h"
-#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "url/origin.h"
 
+namespace content {
+class RenderFrameHost;
+}  // namespace content
+
 namespace on_load_script_injector {
 
 class ON_LOAD_SCRIPT_INJECTOR_EXPORT OriginScopedScript {
@@ -44,10 +40,10 @@ class ON_LOAD_SCRIPT_INJECTOR_EXPORT OriginScopedScript {
 // Manages the set of scripts to be injected into document just prior to
 // document load.
 template <typename ScriptId>
-class OnLoadScriptInjectorHost {
+class ON_LOAD_SCRIPT_INJECTOR_EXPORT OnLoadScriptInjectorHost {
  public:
-  OnLoadScriptInjectorHost() = default;
-  ~OnLoadScriptInjectorHost() = default;
+  OnLoadScriptInjectorHost();
+  ~OnLoadScriptInjectorHost();
 
   OnLoadScriptInjectorHost(const OnLoadScriptInjectorHost&) = delete;
   OnLoadScriptInjectorHost& operator=(const OnLoadScriptInjectorHost&) = delete;
@@ -60,92 +56,23 @@ class OnLoadScriptInjectorHost {
   // All entries of |origins_to_inject| must be valid/not opaque.
   void AddScript(ScriptId id,
                  std::vector<url::Origin> origins_to_inject,
-                 base::StringPiece script) {
-    // If there is no script with the identifier |id|, then create a place for
-    // it at the end of the injection sequence.
-    if (before_load_scripts_.find(id) == before_load_scripts_.end())
-      before_load_scripts_order_.push_back(id);
-
-    // Convert script to UTF-16.
-    base::string16 script_utf16 = base::UTF8ToUTF16(script);
-    size_t script_utf16_size =
-        (base::CheckedNumeric<size_t>(script_utf16.size()) *
-         sizeof(base::char16))
-            .ValueOrDie();
-    base::WritableSharedMemoryRegion script_shared_memory =
-        base::WritableSharedMemoryRegion::Create(script_utf16_size);
-    memcpy(script_shared_memory.Map().memory(), script_utf16.data(),
-           script_utf16_size);
-
-    base::ReadOnlySharedMemoryRegion script_shared_memory_readonly =
-        base::WritableSharedMemoryRegion::ConvertToReadOnly(
-            std::move(script_shared_memory));
-    CHECK(script_shared_memory_readonly.IsValid());
-
-    before_load_scripts_[id] = OriginScopedScript(
-        origins_to_inject, std::move(script_shared_memory_readonly));
-  }
+                 base::StringPiece script);
 
   // Same as AddScript(), except that scripts are injected for all pages.
-  void AddScriptForAllOrigins(ScriptId id, base::StringPiece script) {
-    AddScript(id, {kMatchAllOrigins}, script);
-  }
+  void AddScriptForAllOrigins(ScriptId id, base::StringPiece script);
 
   // Removes the script |id|.
-  void RemoveScript(ScriptId id) {
-    before_load_scripts_.erase(id);
-
-    for (auto script_id_iter = before_load_scripts_order_.begin();
-         script_id_iter != before_load_scripts_order_.end(); ++script_id_iter) {
-      if (*script_id_iter == id) {
-        before_load_scripts_order_.erase(script_id_iter);
-        return;
-      }
-    }
-
-    LOG(WARNING) << "Ignoring attempt to remove unknown OnLoad script: " << id;
-  }
+  void RemoveScript(ScriptId id);
 
   // Injects the scripts associated with the origin of |url| into the document
   // hosted by |render_frame_host|.
   void InjectScriptsForURL(const GURL& url,
-                           content::RenderFrameHost* render_frame_host) {
-    DCHECK(url.is_valid());
-
-    mojo::AssociatedRemote<mojom::OnLoadScriptInjector> injector;
-    render_frame_host->GetRemoteAssociatedInterfaces()->GetInterface(&injector);
-
-    injector->ClearOnLoadScripts();
-
-    if (before_load_scripts_.empty())
-      return;
-
-    // Provision the renderer's ScriptInjector with the scripts associated with
-    // |url|.
-    for (ScriptId script_id : before_load_scripts_order_) {
-      const OriginScopedScript& script = before_load_scripts_[script_id];
-      if (IsUrlMatchedByOriginList(url, script.origins()))
-        injector->AddOnLoadScript(script.script().Duplicate());
-    }
-  }
+                           content::RenderFrameHost* render_frame_host);
 
  private:
   bool IsUrlMatchedByOriginList(
       const GURL& url,
-      const std::vector<url::Origin>& allowed_origins) {
-    url::Origin url_origin = url::Origin::Create(url);
-
-    for (const url::Origin& allowed_origin : allowed_origins) {
-      if (allowed_origin == kMatchAllOrigins)
-        return true;
-
-      DCHECK(!allowed_origin.opaque());
-      if (url_origin.IsSameOriginWith(allowed_origin))
-        return true;
-    }
-
-    return false;
-  }
+      const std::vector<url::Origin>& allowed_origins);
 
   // An opaque Origin that, when specified, allows script injection on all URLs
   // regardless of origin.