Fix a bunch of clang warnings/errors.

base/scoped_nsobject.h

 // Copyright (c) 2009 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 BASE_SCOPED_NSOBJECT_H_
 #define BASE_SCOPED_NSOBJECT_H_
 #pragma once
 
 #import <Foundation/Foundation.h>
 #include "base/basictypes.h"
@@ skipping 31 matching lines @@
   void reset(NST* object = nil) {
     // We intentionally do not check that object != object_ as the caller must
     // already have an ownership claim over whatever it gives to scoped_nsobject
     // and scoped_cftyperef, whether it's in the constructor or in a call to
     // reset().  In either case, it relinquishes that claim and the scoper
     // assumes it.
     [object_ release];
     object_ = object;
   }
 
-  bool operator==(NST* that) const {
-    return object_ == that;
-  }
-
-  bool operator!=(NST* that) const {
-    return object_ != that;
-  }
+  bool operator==(NST* that) const { return object_ == that; }
+  bool operator!=(NST* that) const { return object_ != that; }
 
   operator NST*() const {
     return object_;
   }
 
   NST* get() const {
     return object_;
   }
 
   void swap(scoped_nsobject& that) {
@@ skipping 10 matching lines @@
     object_ = nil;
     return temp;
   }
 
  private:
   NST* object_;
 
   DISALLOW_COPY_AND_ASSIGN(scoped_nsobject);
 };
 
+// Free functions
+template <class C>
+void swap(scoped_nsobject<C>& p1, scoped_nsobject<C>& p2) {

[Mark Mentovai, 2010/09/21 18:40:01]

What uses swap as a free guy?

+  p1.swap(p2);
+}
+
+template <class C>
+bool operator==(C* p1, const scoped_nsobject<C>& p2) {
+  return p1 == p2.get();
+}
+
+template <class C>
+bool operator!=(C* p1, const scoped_nsobject<C>& p2) {
+  return p1 != p2.get();
+}
+
+
 // Specialization to make scoped_nsobject<id> work.
 template<>
 class scoped_nsobject<id> {
  public:
   typedef id element_type;
 
   explicit scoped_nsobject(id object = nil)
       : object_(object) {
   }
 
   ~scoped_nsobject() {
     [object_ release];
   }
 
   void reset(id object = nil) {
     // We intentionally do not check that object != object_ as the caller must
     // already have an ownership claim over whatever it gives to scoped_nsobject
     // and scoped_cftyperef, whether it's in the constructor or in a call to
     // reset().  In either case, it relinquishes that claim and the scoper
     // assumes it.
     [object_ release];
     object_ = object;
   }
 
-  bool operator==(id that) const {
-    return object_ == that;
-  }
-
-  bool operator!=(id that) const {
-    return object_ != that;
-  }
+  bool operator==(id that) const { return object_ == that; }
+  bool operator!=(id that) const { return object_ != that; }
 
   operator id() const {
     return object_;
   }
 
   id get() const {
     return object_;
   }
 
   void swap(scoped_nsobject& that) {
@@ skipping 21 matching lines @@
 // ScopedNSAutoreleasePool instead. This is a compile time check. See details
 // at top of header.
 template<>
 class scoped_nsobject<NSAutoreleasePool> {
  private:
   explicit scoped_nsobject(NSAutoreleasePool* object = nil);
   DISALLOW_COPY_AND_ASSIGN(scoped_nsobject);
 };
 
 #endif  // BASE_SCOPED_NSOBJECT_H_