Introduce HostID and de-couple Extensions from "script injection System" [browser side]

extensions/common/consumer.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_CONSUMER_H_
+#define EXTENSIONS_COMMON_CONSUMER_H_
+
+#include <string>
+
+#include "base/macros.h"
+
+// IDs of API consumers who own user scripts.
+// A ConsumerID is immutable after creation.
+// For example: an extension, a <webview> created by an extension,

[Devlin, 2015/01/14 16:45:10]

This needs to be re-worded.  Maybe something like:
A ConsumerID could be used for an extension...

[Xi Han, 2015/01/14 23:46:04]

It sounds better:)

+// a <webview> created by WebUI.
+class ConsumerID {

[Devlin, 2015/01/14 16:45:10]

See also main comment on making this a struct.

[Xi Han, 2015/01/14 23:46:04]

Done.

+ public:
+  // The type of a host who contains regular tabs or <webview>s.
+  enum HostType { EXTENSIONS, WEBUI };
+
+  enum InstanceType { TAB, WEBVIEW };
+
+  // Default instance ID of a consumer who owns statically defined user scripts.
+  static const int kDefaultInstanceID;
+
+  explicit ConsumerID(const ConsumerID& other);
+  ConsumerID(HostType host_type,
+             const std::string& host_id,
+             InstanceType instance_type,
+             int instance_id);
+  ~ConsumerID();
+
+  // Returns a reference to a singleton empty ConsumerID.
+  static const ConsumerID& EmptyConsumerID();

[Devlin, 2015/01/14 16:45:10]

Why do we need this, instead of just creating a new empty one?

[Xi Han, 2015/01/14 23:46:03]

Hmmm, having many copies of empty one seems wasteful, since a ConsumerID is
immutable after creation. So I think we can reuse the same reference of an empty
one. Any concern about it? 

[Devlin, 2015/01/16 17:05:04]

Yeah -- there's no real cheap way to do it.  Your current implementation uses a
static scoped_ptr, which is a code violation (only plain-old-data statics are
allowed), and things like singletons and lazy instances are deceptively
expensive.  See also comments above, e.g., base::EmptyString() encouraging the
use of a newly-constructed object whenever possible.  If we don't need to pass a
reference around for memory management reasons, it's best to just create a new
empty one each time (it's really cheap for an object like a ConsumerID).

[Xi Han, 2015/01/19 22:40:05]

That is a good point. Since we add the default constructor of ConsumerID back,
we don't need this function anymore.

+
+  // Get next available instance ID.
+  static int GetNextID();
+
+  bool operator<(const ConsumerID& id) const;
+
+  HostType host_type() const { return host_type_; }
+  const std::string& host_id() const { return host_id_; }
+  InstanceType instance_type() const { return instance_type_; }
+  int instance_id() const { return instance_id_; }
+
+ private:
+  // Extension or WebUI.
+  const HostType host_type_;
+
+  // Similar to extension_id, host_id is a unique indentifier for a host,
+  // e.g., an Extension or WebUI.
+  const std::string host_id_;
+
+  // A tab or a <webiew>.
+  const InstanceType instance_type_;
+
+  // For a consumer that owns staticlly defined user scripts, the
+  // |instance_id| is 0;
+  // For a consumer that owns declarative user scripts, the |instance_id|
+  // is assigned by DeclarativeUserScriptManager when the consumer requests a
+  // master object.
+  const int instance_id_;
+};
+
+// Represents an API consumer.
+class Consumer {
+ public:
+  Consumer();
+  virtual ~Consumer();
+
+  DISALLOW_COPY_AND_ASSIGN(Consumer);
+};
+
+#endif  // EXTENSIONS_COMMON_CONSUMER_H_