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

extensions/common/host_id.h

 // Copyright 2015 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 EXTENSIONS_COMMON_HOST_ID_H_
 #define EXTENSIONS_COMMON_HOST_ID_H_
 
 #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 {
   enum HostType { EXTENSIONS, WEBUI };
 
   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())
       return type_ < host_id.type();
     else if (id_ != host_id.id())
       return id_ < host_id.id();
     return false;
   }
 
   HostType type() const { return type_; }
   const std::string& id() const { return id_; }
 
  private:
   // The type of the host.
   HostType type_;
 
   // Similar to extension_id, host_id is a unique indentifier for a host,
   // e.g., an Extension or WebUI.
   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_