Use base::STLSet* in place of std::set_* for simplicity.

extensions/common/permissions/set_disjunction_permission.h

 // Copyright 2014 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_PERMISSIONS_SET_DISJUNCTION_PERMISSION_H_
 #define EXTENSIONS_COMMON_PERMISSIONS_SET_DISJUNCTION_PERMISSION_H_
 
-#include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_utils.h"
@@ skipping 26 matching lines @@
       if (i->Check(param))
         return true;
     }
     return false;
   }
 
   virtual bool Contains(const APIPermission* rhs) const OVERRIDE {
     CHECK(rhs->info() == info());
     const SetDisjunctionPermission* perm =
         static_cast<const SetDisjunctionPermission*>(rhs);
-    return std::includes(data_set_.begin(),
-                         data_set_.end(),
-                         perm->data_set_.begin(),
-                         perm->data_set_.end());
+    return base::STLIncludes<std::set<PermissionDataType> >(
+        data_set_, perm->data_set_);
   }
 
   virtual bool Equal(const APIPermission* rhs) const OVERRIDE {
     CHECK(rhs->info() == info());
     const SetDisjunctionPermission* perm =
         static_cast<const SetDisjunctionPermission*>(rhs);
     return data_set_ == perm->data_set_;
   }
 
   virtual APIPermission* Clone() const OVERRIDE {
     SetDisjunctionPermission* result = new DerivedType(info());
     result->data_set_ = data_set_;
     return result;
   }
 
   virtual APIPermission* Diff(const APIPermission* rhs) const OVERRIDE {
     CHECK(rhs->info() == info());
     const SetDisjunctionPermission* perm =
         static_cast<const SetDisjunctionPermission*>(rhs);
     scoped_ptr<SetDisjunctionPermission> result(new DerivedType(info()));
-    std::set_difference(data_set_.begin(),
-                        data_set_.end(),
-                        perm->data_set_.begin(),
-                        perm->data_set_.end(),
-                        std::inserter<std::set<PermissionDataType> >(
-                            result->data_set_, result->data_set_.begin()));
+    result->data_set_ = base::STLSetDifference<std::set<PermissionDataType> >(
+        data_set_, perm->data_set_);
     return result->data_set_.empty() ? NULL : result.release();
   }
 
   virtual APIPermission* Union(const APIPermission* rhs) const OVERRIDE {
     CHECK(rhs->info() == info());
     const SetDisjunctionPermission* perm =
         static_cast<const SetDisjunctionPermission*>(rhs);
     scoped_ptr<SetDisjunctionPermission> result(new DerivedType(info()));
-    std::set_union(data_set_.begin(),
-                   data_set_.end(),
-                   perm->data_set_.begin(),
-                   perm->data_set_.end(),
-                   std::inserter<std::set<PermissionDataType> >(
-                       result->data_set_, result->data_set_.begin()));
+    result->data_set_ = base::STLSetUnion<std::set<PermissionDataType> >(
+        data_set_, perm->data_set_);
     return result.release();
   }
 
   virtual APIPermission* Intersect(const APIPermission* rhs) const OVERRIDE {
     CHECK(rhs->info() == info());
     const SetDisjunctionPermission* perm =
         static_cast<const SetDisjunctionPermission*>(rhs);
     scoped_ptr<SetDisjunctionPermission> result(new DerivedType(info()));
-    std::set_intersection(data_set_.begin(),
-                          data_set_.end(),
-                          perm->data_set_.begin(),
-                          perm->data_set_.end(),
-                          std::inserter<std::set<PermissionDataType> >(
-                              result->data_set_, result->data_set_.begin()));
+    result->data_set_ = base::STLSetIntersection<std::set<PermissionDataType> >(
+        data_set_, perm->data_set_);
     return result->data_set_.empty() ? NULL : result.release();
   }
 
   virtual bool FromValue(
       const base::Value* value,
       std::string* error,
       std::vector<std::string>* unhandled_permissions) OVERRIDE {
     data_set_.clear();
     const base::ListValue* list = NULL;
 
@@ skipping 51 matching lines @@
     IPC::LogParam(data_set_, log);
   }
 
  protected:
   std::set<PermissionDataType> data_set_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_PERMISSIONS_SET_DISJUNCTION_PERMISSION_H_