Do not typedef ExtensionId/ID, since it's already available in extension_id.h

extensions/browser/api/declarative_webrequest/webrequest_rules_registry.cc

 // Copyright (c) 2012 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 "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_condition.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/browser/api/web_request/web_request_permissions.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/extension_id.h"

[Devlin, 2016/11/11 23:10:06]

don't need this here; it's in the .h

[lazyboy, 2016/11/12 00:13:16]

Done.

 #include "extensions/common/permissions/permissions_data.h"
 #include "net/url_request/url_request.h"
 
 using url_matcher::URLMatcherConditionSet;
 
 namespace {
 
 const char kActionCannotBeExecuted[] = "The action '*' can never be executed "
     "because there are is no time in the request life-cycle during which the "
     "conditions can be checked and the action can possibly be executed.";
@@ skipping 62 matching lines @@
   ordered_matches.reserve(matches.size());
   for (const WebRequestRule* rule : matches)
     ordered_matches.push_back(make_pair(rule->priority(), rule->id()));
   // Sort from rbegin to rend in order to get descending priority order.
   std::sort(ordered_matches.rbegin(), ordered_matches.rend());
 
   // Build a map that maps each extension id to the minimum required priority
   // for rules of that extension. Initially, this priority is -infinite and
   // will be increased when the rules are processed and raise the bar via
   // WebRequestIgnoreRulesActions.
-  typedef std::string ExtensionId;
   typedef std::map<ExtensionId, WebRequestRule::Priority> MinPriorities;
   typedef std::map<ExtensionId, std::set<std::string> > IgnoreTags;
   MinPriorities min_priorities;
   IgnoreTags ignore_tags;
   for (const PriorityRuleIdPair& priority_rule_id_pair : ordered_matches) {
     const WebRequestRule::GlobalRuleId& rule_id = priority_rule_id_pair.second;
     const ExtensionId& extension_id = rule_id.first;
     min_priorities[extension_id] = std::numeric_limits<int>::min();
   }
 
@@ skipping 169 matching lines @@
   }
   rules_with_untriggered_conditions_.erase(rule);
 }
 
 bool WebRequestRulesRegistry::IsEmpty() const {
   // Easy first.
   if (!rule_triggers_.empty() && url_matcher_.IsEmpty())
     return false;
 
   // Now all the registered rules for each extensions.
-  for (const std::pair<WebRequestRule::ExtensionId, RulesMap>&
-           extension_id_rules_map_pair : webrequest_rules_) {
+  for (const std::pair<ExtensionId, RulesMap>& extension_id_rules_map_pair :
+       webrequest_rules_) {
     if (!extension_id_rules_map_pair.second.empty())
       return false;
   }
   return true;
 }
 
 WebRequestRulesRegistry::~WebRequestRulesRegistry() {}
 
 base::Time WebRequestRulesRegistry::GetExtensionInstallationTime(
     const std::string& extension_id) const {
@@ skipping 70 matching lines @@
   for (url_matcher::URLMatcherConditionSet::ID url_match : url_matches) {
     RuleTriggers::const_iterator rule_trigger = rule_triggers_.find(url_match);
     CHECK(rule_trigger != rule_triggers_.end());
     if (!base::ContainsKey(*result, rule_trigger->second) &&
         rule_trigger->second->conditions().IsFulfilled(url_match, request_data))
       result->insert(rule_trigger->second);
   }
 }
 
 }  // namespace extensions