Refactoring: de-couple Extensions from "script injection System" [render side] : 1

extensions/common/host_id.h

Index: extensions/common/host_id.h
diff --git a/extensions/common/host_id.h b/extensions/common/host_id.h
index 004480704f07766662006c7c3c570883c7e9a296..08d1b14d22b43b9a0860faa52cff35479231a43a 100644
--- a/extensions/common/host_id.h
+++ b/extensions/common/host_id.h
@@ -7,6 +7,9 @@
 
 #include <string>
 
+#include "base/macros.h"
+#include "url/gurl.h"
+
 // IDs of hosts who own user scripts.
 // A HostID is immutable after creation.
 struct HostID {
@@ -15,6 +18,9 @@ struct HostID {
   HostID() {}
   HostID(HostType type, const std::string& id)
       : type_(type), id_(id) {}
+  HostID(const HostID& host_id)
+      : type_(host_id.type()),
+        id_(host_id.id()) {}
 
   bool operator<(const HostID& host_id) const {
     if (type_ != host_id.type())
@@ -36,4 +42,35 @@ struct HostID {
   std::string id_;
 };
 
+// An interface for all kinds of hosts who own user scripts.
+class Host {
+ public:
+  // The default id of the instance that host will inject the script.
+  // If the instance is a regular tab, the |instance_id| is 0; if the instance
+  // is <webview>, the |instance_id| is a unique number that is bigger than 0.
+  static const int kDefaultInstanceId;
+
+  Host(const HostID& host_id);
+  virtual ~Host();
+
+  // Returns if the Host owns a non-empty pointer to the real host object
+  // (extension, or WebUI).

[Devlin, 2015/02/06 00:28:41]

The idea of a Host being non-null but "empty" is weird.  Why make one if it's
going to be empty, instead of just not creating it at all (and checking the host
for nullness?)

[Xi Han, 2015/02/06 17:21:45]

My initial thoughts was we may have a WebUIConsumer, but it doesn't have such a
pointer of an object of the real host(like scoped_ptr<const Extension> in
ExtensionConsumer). In many places, we need a check to replace the
"if(!extension)" check, and the check will look like: if(host_type == EXTENSION
&& !extension). We always want to know the type of the host, so we can
distinguish whether is the extension is gone, or it is a webUI. 

[Devlin, 2015/02/06 18:48:36]

Well, all interactions from the script injection should go through the Host, not
through the host's backing object.  So a _host_ should always be able to answer
things like "GetContentSecurityPolicy".  If it's a webui and able to answer
these questions without a backing pointer (which it should be able to), that's
fine - but having to always check that !host->IsEmpty() seems cumbersome, when
if the host is empty (and needs to not be empty), there's nothing we can do. 
Instead, we should only create valid hosts (for extensions, this means that we
should only pass in hosts that have a backing extension).

[Xi Han, 2015/02/06 19:45:33]

That is fair. We can create a Host object for webUI even with an null pointer
inside; while create a null ptr if the extension is gone. In this way, "!host"
will always means the host is gone. 

+  virtual bool IsEmpty() const = 0;
+
+  virtual const std::string& GetContentSecurityPolicy() const = 0;
+
+  // The base url for the host.
+  virtual const GURL& url() const = 0;
+
+  // The human-readable name of the host.
+  virtual const std::string name() const = 0;
+
+  const HostID& id() const { return id_; }
+ private:
+  // The ID of the host.
+  HostID id_;
+
+  DISALLOW_COPY_AND_ASSIGN(Host);
+};
+
 #endif  // EXTENSIONS_COMMON_HOST_ID_H_