tools/gn: Fix errors found by Facebook's flint tool.

tools/gn/scope.h

 // Copyright (c) 2013 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 TOOLS_GN_SCOPE_H_
 #define TOOLS_GN_SCOPE_H_
 
 #include <map>
 #include <set>
 
@@ skipping 30 matching lines @@
  public:
   typedef base::hash_map<base::StringPiece, Value> KeyValueMap;
   // Holds an owning list of Items.
   typedef ScopedVector<Item> ItemVector;
 
   // Allows code to provide values for built-in variables. This class will
   // automatically register itself on construction and deregister itself on
   // destruction.
   class ProgrammaticProvider {
    public:
-    ProgrammaticProvider(Scope* scope) : scope_(scope) {
+    explicit ProgrammaticProvider(Scope* scope) : scope_(scope) {
       scope_->AddProvider(this);
     }
-    ~ProgrammaticProvider() {
-      scope_->RemoveProvider(this);
-    }
+    virtual ~ProgrammaticProvider();
 
     // Returns a non-null value if the given value can be programmatically
     // generated, or NULL if there is none.
     virtual const Value* GetProgrammaticValue(
         const base::StringPiece& ident) = 0;
 
    protected:
     Scope* scope_;
   };
 
@@ skipping 22 matching lines @@
     bool skip_private_vars;
 
     // When set, values copied to the destination scope will be marked as used
     // so won't trigger an unused variable warning. You want this when doing an
     // import, for example, or files that don't need a variable from the .gni
     // file will throw an error.
     bool mark_used;
   };
 
   // Creates an empty toplevel scope.
-  Scope(const Settings* settings);
+  explicit Scope(const Settings* settings);
 
   // Creates a dependent scope.
-  Scope(Scope* parent);
-  Scope(const Scope* parent);
+  explicit Scope(Scope* parent);
+  explicit Scope(const Scope* parent);
 
   ~Scope();
 
   const Settings* settings() const { return settings_; }
 
   // See the const_/mutable_containing_ var declaraions below. Yes, it's a
   // bit weird that we can have a const pointer to the "mutable" one.
   Scope* mutable_containing() { return mutable_containing_; }
   const Scope* mutable_containing() const { return mutable_containing_; }
   const Scope* const_containing() const { return const_containing_; }
@@ skipping 177 matching lines @@
   // |found_on_scope| variable will be filled with the actual scope containing
   // the key (if the pointer is non-NULL).
   void SetProperty(const void* key, void* value);
   void* GetProperty(const void* key, const Scope** found_on_scope) const;
 
  private:
   friend class ProgrammaticProvider;
 
   struct Record {
     Record() : used(false) {}
-    Record(const Value& v) : used(false), value(v) {}
+    explicit Record(const Value& v) : used(false), value(v) {}
 
     bool used;  // Set to true when the variable is used.
     Value value;
   };
 
   void AddProvider(ProgrammaticProvider* p);
   void RemoveProvider(ProgrammaticProvider* p);
 
   // Scopes can have no containing scope (both null), a mutable containing
   // scope, or a const containing scope. The reason is that when we're doing
@@ skipping 35 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_