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 <stddef.h>
      9 
     10 #include <string>
     11 #include <vector>
     12 
     13 #include "base/base_export.h"
     14 #include "base/compiler_specific.h"
     15 #include "base/macros.h"
     16 #include "base/memory/ref_counted.h"
     17 
     18 namespace base {
     19 
     20 // A generic interface to memory. This object is reference counted because one
     21 // of its two subclasses own the data they carry, and we need to have
     22 // heterogeneous containers of these two types of memory.
     23 class BASE_EXPORT RefCountedMemory
     24     : public base::RefCountedThreadSafe<RefCountedMemory> {
     25  public:
     26   // Retrieves a pointer to the beginning of the data we point to. If the data
     27   // is empty, this will return NULL.
     28   virtual const unsigned char* front() const = 0;
     29 
     30   // Size of the memory pointed to.
     31   virtual size_t size() const = 0;
     32 
     33   // Returns true if |other| is byte for byte equal.
     34   bool Equals(const scoped_refptr<RefCountedMemory>& other) const;
     35 
     36   // Handy method to simplify calling front() with a reinterpret_cast.
     37   template<typename T> const T* front_as() const {
     38     return reinterpret_cast<const T*>(front());
     39   }
     40 
     41  protected:
     42   friend class base::RefCountedThreadSafe<RefCountedMemory>;
     43   RefCountedMemory();
     44   virtual ~RefCountedMemory();
     45 };
     46 
     47 // An implementation of RefCountedMemory, where the ref counting does not
     48 // matter.
     49 class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory {
     50  public:
     51   RefCountedStaticMemory()
     52       : data_(NULL), length_(0) {}
     53   RefCountedStaticMemory(const void* data, size_t length)
     54       : data_(static_cast<const unsigned char*>(length ? data : NULL)),
     55         length_(length) {}
     56 
     57   // Overridden from RefCountedMemory:
     58   const unsigned char* front() const override;
     59   size_t size() const override;
     60 
     61  private:
     62   ~RefCountedStaticMemory() override;
     63 
     64   const unsigned char* data_;
     65   size_t length_;
     66 
     67   DISALLOW_COPY_AND_ASSIGN(RefCountedStaticMemory);
     68 };
     69 
     70 // An implementation of RefCountedMemory, where we own the data in a vector.
     71 class BASE_EXPORT RefCountedBytes : public RefCountedMemory {
     72  public:
     73   RefCountedBytes();
     74 
     75   // Constructs a RefCountedBytes object by _copying_ from |initializer|.
     76   explicit RefCountedBytes(const std::vector<unsigned char>& initializer);
     77 
     78   // Constructs a RefCountedBytes object by copying |size| bytes from |p|.
     79   RefCountedBytes(const unsigned char* p, size_t size);
     80 
     81   // Constructs a RefCountedBytes object by performing a swap. (To non
     82   // destructively build a RefCountedBytes, use the constructor that takes a
     83   // vector.)
     84   static RefCountedBytes* TakeVector(std::vector<unsigned char>* to_destroy);
     85 
     86   // Overridden from RefCountedMemory:
     87   const unsigned char* front() const override;
     88   size_t size() const override;
     89 
     90   const std::vector<unsigned char>& data() const { return data_; }
     91   std::vector<unsigned char>& data() { return data_; }
     92 
     93  private:
     94   ~RefCountedBytes() override;
     95 
     96   std::vector<unsigned char> data_;
     97 
     98   DISALLOW_COPY_AND_ASSIGN(RefCountedBytes);
     99 };
    100 
    101 // An implementation of RefCountedMemory, where the bytes are stored in an STL
    102 // string. Use this if your data naturally arrives in that format.
    103 class BASE_EXPORT RefCountedString : public RefCountedMemory {
    104  public:
    105   RefCountedString();
    106 
    107   // Constructs a RefCountedString object by performing a swap. (To non
    108   // destructively build a RefCountedString, use the default constructor and
    109   // copy into object->data()).
    110   static scoped_refptr<RefCountedString> TakeString(std::string* to_destroy);
    111 
    112   // Overridden from RefCountedMemory:
    113   const unsigned char* front() const override;
    114   size_t size() const override;
    115 
    116   const std::string& data() const { return data_; }
    117   std::string& data() { return data_; }
    118 
    119  private:
    120   ~RefCountedString() override;
    121 
    122   std::string data_;
    123 
    124   DISALLOW_COPY_AND_ASSIGN(RefCountedString);
    125 };
    126 
    127 }  // namespace base
    128 
    129 #endif  // BASE_MEMORY_REF_COUNTED_MEMORY_H_
    130