Home | History | Annotate | Download | only in memory 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef BASE_MEMORY_REF_COUNTED_MEMORY_H_
      6 #define BASE_MEMORY_REF_COUNTED_MEMORY_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/base_export.h"
     12 #include "base/compiler_specific.h"
     13 #include "base/memory/ref_counted.h"
     14 
     15 namespace base {
     16 
     17 // A generic interface to memory. This object is reference counted because one
     18 // of its two subclasses own the data they carry, and we need to have
     19 // heterogeneous containers of these two types of memory.
     20 class BASE_EXPORT RefCountedMemory
     21     : public base::RefCountedThreadSafe<RefCountedMemory> {
     22  public:
     23   // Retrieves a pointer to the beginning of the data we point to. If the data
     24   // is empty, this will return NULL.
     25   virtual const unsigned char* front() const = 0;
     26 
     27   // Size of the memory pointed to.
     28   virtual size_t size() const = 0;
     29 
     30   // Returns true if |other| is byte for byte equal.
     31   bool Equals(const scoped_refptr<RefCountedMemory>& other) const;
     32 
     33  protected:
     34   friend class base::RefCountedThreadSafe<RefCountedMemory>;
     35   RefCountedMemory();
     36   virtual ~RefCountedMemory();
     37 };
     38 
     39 // An implementation of RefCountedMemory, where the ref counting does not
     40 // matter.
     41 class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory {
     42  public:
     43   RefCountedStaticMemory()
     44       : data_(NULL), length_(0) {}
     45   RefCountedStaticMemory(const unsigned char* data, size_t length)
     46       : data_(length ? data : NULL), length_(length) {}
     47 
     48   // Overridden from RefCountedMemory:
     49   virtual const unsigned char* front() const OVERRIDE;
     50   virtual size_t size() const OVERRIDE;
     51 
     52  private:
     53   virtual ~RefCountedStaticMemory();
     54 
     55   const unsigned char* data_;
     56   size_t length_;
     57 
     58   DISALLOW_COPY_AND_ASSIGN(RefCountedStaticMemory);
     59 };
     60 
     61 // An implementation of RefCountedMemory, where we own our the data in a
     62 // vector.
     63 class BASE_EXPORT RefCountedBytes : public RefCountedMemory {
     64  public:
     65   RefCountedBytes();
     66 
     67   // Constructs a RefCountedBytes object by _copying_ from |initializer|.
     68   explicit RefCountedBytes(const std::vector<unsigned char>& initializer);
     69 
     70   // Constructs a RefCountedBytes object by performing a swap. (To non
     71   // destructively build a RefCountedBytes, use the constructor that takes a
     72   // vector.)
     73   static RefCountedBytes* TakeVector(std::vector<unsigned char>* to_destroy);
     74 
     75   // Overridden from RefCountedMemory:
     76   virtual const unsigned char* front() const OVERRIDE;
     77   virtual size_t size() const OVERRIDE;
     78 
     79   const std::vector<unsigned char>& data() const { return data_; }
     80   std::vector<unsigned char>& data() { return data_; }
     81 
     82  private:
     83   virtual ~RefCountedBytes();
     84 
     85   std::vector<unsigned char> data_;
     86 
     87   DISALLOW_COPY_AND_ASSIGN(RefCountedBytes);
     88 };
     89 
     90 // An implementation of RefCountedMemory, where the bytes are stored in an STL
     91 // string. Use this if your data naturally arrives in that format.
     92 class BASE_EXPORT RefCountedString : public RefCountedMemory {
     93  public:
     94   RefCountedString();
     95 
     96   // Constructs a RefCountedString object by performing a swap. (To non
     97   // destructively build a RefCountedString, use the default constructor and
     98   // copy into object->data()).
     99   static RefCountedString* TakeString(std::string* to_destroy);
    100 
    101   // Overridden from RefCountedMemory:
    102   virtual const unsigned char* front() const OVERRIDE;
    103   virtual size_t size() const OVERRIDE;
    104 
    105   const std::string& data() const { return data_; }
    106   std::string& data() { return data_; }
    107 
    108  private:
    109   virtual ~RefCountedString();
    110 
    111   std::string data_;
    112 
    113   DISALLOW_COPY_AND_ASSIGN(RefCountedString);
    114 };
    115 
    116 // An implementation of RefCountedMemory that holds a chunk of memory
    117 // previously allocated with malloc or calloc, and that therefore must be freed
    118 // using free().
    119 class BASE_EXPORT RefCountedMallocedMemory : public base::RefCountedMemory {
    120  public:
    121   RefCountedMallocedMemory(void* data, size_t length);
    122 
    123   // Overridden from RefCountedMemory:
    124   virtual const unsigned char* front() const OVERRIDE;
    125   virtual size_t size() const OVERRIDE;
    126 
    127  private:
    128   virtual ~RefCountedMallocedMemory();
    129 
    130   unsigned char* data_;
    131   size_t length_;
    132 
    133   DISALLOW_COPY_AND_ASSIGN(RefCountedMallocedMemory);
    134 };
    135 
    136 }  // namespace base
    137 
    138 #endif  // BASE_MEMORY_REF_COUNTED_MEMORY_H_
    139