Remove two unused header files from ppapi/native_client/

BUG=https://code.google.com/p/nativeclient/issues/detail?id=2500
TEST=build

Review URL: https://codereview.chromium.org/19515002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212064 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 0 insertions, 257 deletions

diff --git a/ppapi/native_client/src/include/nacl_memory.h b/ppapi/native_client/src/include/nacl_memory.h
deleted file mode 100644
index 2930d9e..0000000
--- a/ppapi/native_client/src/include/nacl_memory.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 2011 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 NATIVE_CLIENT_SRC_INCLUDE_MEMORY_H_
-#define NATIVE_CLIENT_SRC_INCLUDE_MEMORY_H_
-
-// Platform-specific includes for tr1::memory.  The file is in a different
-// location on Windows than on *nix platforms.
-
-#ifdef __cplusplus
-
-#if NACL_LINUX || NACL_OSX || __native_client__
-#include <tr1/memory>
-#elif NACL_WINDOWS
-#include <memory>
-#else
-#error "tr1::memory header file not available for this platform."
-#endif
-
-#endif  // __cplusplus
-
-#endif  // NATIVE_CLIENT_SRC_INCLUDE_MEMORY_H_
-
diff --git a/ppapi/native_client/src/include/ref_counted.h b/ppapi/native_client/src/include/ref_counted.h
deleted file mode 100644
index 98c50ed..0000000
--- a/ppapi/native_client/src/include/ref_counted.h
+++ /dev/null
@@ -1,233 +0,0 @@
-// 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.
-
-#ifndef NATIVE_CLIENT_SRC_INCLUDE_REF_COUNTED_H_
-#define NATIVE_CLIENT_SRC_INCLUDE_REF_COUNTED_H_
-
-#include "native_client/src/shared/platform/nacl_sync_checked.h"
-
-namespace nacl {
-
-namespace subtle {
-
-class RefCountedBase {
- public:
-  bool HasOneRef() const {
-    nacl::ScopedNaClMutexLock ml(&mu_);
-    return (ref_count_ == 1);
-  }
-
- protected:
-  RefCountedBase() : ref_count_(0) {
-    NaClXMutexCtor(&mu_);
-  }
-  ~RefCountedBase() {
-    NaClMutexDtor(&mu_);
-  }
-
-  void AddRef() const {
-    nacl::ScopedNaClMutexLock ml(&mu_);
-    ++ref_count_;
-  }
-
-  // Returns true if the object should self-delete.
-  bool Release() const {
-    nacl::ScopedNaClMutexLock ml(&mu_);
-    bool should_delete = (--ref_count_ == 0);
-    return should_delete;
-  }
-
- private:
-  mutable int ref_count_;
-  mutable struct NaClMutex mu_;
-
-  RefCountedBase(const RefCountedBase&);
-  void operator=(const RefCountedBase&);
-};
-
-}  // namespace subtle
-
-//
-// A base class for reference counted classes.  Otherwise, known as a cheap
-// knock-off of WebKit's RefCounted<T> class.  To use this guy just extend your
-// class from it like so:
-//
-//   class MyFoo : public nacl::RefCounted<MyFoo> {
-//    ...
-//    private:
-//     friend class nacl::RefCounted<MyFoo>;
-//     ~MyFoo();
-//   };
-//
-// You should always make your destructor private, to avoid any code deleting
-// the object accidently while there are references to it.
-template <class T>
-class RefCountedThreadSafe : public subtle::RefCountedBase {
- public:
-  RefCountedThreadSafe() {}
-
-  void AddRef() const {
-    subtle::RefCountedBase::AddRef();
-  }
-
-  void Release() const {
-    if (subtle::RefCountedBase::Release()) {
-      delete static_cast<const T*>(this);
-    }
-  }
-
- protected:
-  ~RefCountedThreadSafe() {}
-
- private:
-  RefCountedThreadSafe(const RefCountedThreadSafe<T>&);
-  void operator=(const RefCountedThreadSafe<T>&);
-};
-
-//
-// A wrapper for some piece of data so we can place other things in
-// scoped_refptrs<>.
-//
-template<typename T>
-class RefCountedData
-    : public RefCountedThreadSafe<RefCountedData<T> > {
- public:
-  RefCountedData() : data() {}
-  RefCountedData(const T& in_value) : data(in_value) {}
-
-  T data;
-};
-
-}  // namespace nacl
-
-//
-// A smart pointer class for reference counted objects.  Use this class instead
-// of calling AddRef and Release manually on a reference counted object to
-// avoid common memory leaks caused by forgetting to Release an object
-// reference.  Sample usage:
-//
-//   class MyFoo : public RefCounted<MyFoo> {
-//    ...
-//   };
-//
-//   void some_function() {
-//     scoped_refptr<MyFoo> foo = new MyFoo();
-//     foo->Method(param);
-//     // |foo| is released when this function returns
-//   }
-//
-//   void some_other_function() {
-//     scoped_refptr<MyFoo> foo = new MyFoo();
-//     ...
-//     foo = NULL;  // explicitly releases |foo|
-//     ...
-//     if (foo)
-//       foo->Method(param);
-//   }
-//
-// The above examples show how scoped_refptr<T> acts like a pointer to T.
-// Given two scoped_refptr<T> classes, it is also possible to exchange
-// references between the two objects, like so:
-//
-//   {
-//     scoped_refptr<MyFoo> a = new MyFoo();
-//     scoped_refptr<MyFoo> b;
-//
-//     b.swap(a);
-//     // now, |b| references the MyFoo object, and |a| references NULL.
-//   }
-//
-// To make both |a| and |b| in the above example reference the same MyFoo
-// object, simply use the assignment operator:
-//
-//   {
-//     scoped_refptr<MyFoo> a = new MyFoo();
-//     scoped_refptr<MyFoo> b;
-//
-//     b = a;
-//     // now, |a| and |b| each own a reference to the same MyFoo object.
-//   }
-//
-template <class T>
-class scoped_refptr {
- public:
-  scoped_refptr() : ptr_((T*)0) {}
-
-  scoped_refptr(T* p) : ptr_(p) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  template <typename U>
-  scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
-    if (ptr_)
-      ptr_->AddRef();
-  }
-
-  ~scoped_refptr() {
-    if (ptr_)
-      ptr_->Release();
-  }
-
-  T* get() const { return ptr_; }
-  operator T*() const { return ptr_; }
-  T* operator->() const { return ptr_; }
-
-  // Release a pointer.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  T* release() {
-    T* retVal = ptr_;
-    ptr_ = (void*)0;
-    return retVal;
-  }
-
-  scoped_refptr<T>& operator=(T* p) {
-    // AddRef first so that self assignment should work
-    if (p)
-      p->AddRef();
-    if (ptr_ )
-      ptr_ ->Release();
-    ptr_ = p;
-    return *this;
-  }
-
-  scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
-    return *this = r.ptr_;
-  }
-
-  template <typename U>
-  scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
-    return *this = r.get();
-  }
-
-  void swap(T** pp) {
-    T* p = ptr_;
-    ptr_ = *pp;
-    *pp = p;
-  }
-
-  void swap(scoped_refptr<T>& r) {
-    swap(&r.ptr_);
-  }
-
- protected:
-  T* ptr_;
-};
-
-// Handy utility for creating a scoped_refptr<T> out of a T* explicitly without
-// having to retype all the template arguments
-template <typename T>
-scoped_refptr<T> make_scoped_refptr(T* t) {
-  return scoped_refptr<T>(t);
-}
-
-#endif  // NATIVE_CLIENT_SRC_INCLUDE_REF_COUNTED_H_