webkit/common/data_element.h

   1 // Copyright 2013 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 WEBKIT_COMMON_DATA_ELEMENT_H_
   6 #define WEBKIT_COMMON_DATA_ELEMENT_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/files/file_path.h"
  13 #include "base/logging.h"
  14 #include "base/time/time.h"
  15 #include "url/gurl.h"
  16 #include "webkit/common/webkit_common_export.h"
  17
  18 namespace webkit_common {
  19
  20 // Represents a base Web data element. This could be either one of
  21 // bytes, file or blob data.
  22 class WEBKIT_COMMON_EXPORT DataElement {
  23  public:
  24   enum Type {
  25     TYPE_UNKNOWN = -1,
  26     TYPE_BYTES,
  27     TYPE_FILE,
  28     TYPE_BLOB,
  29     TYPE_FILE_FILESYSTEM,
  30   };
  31
  32   DataElement();
  33   ~DataElement();
  34
  35   Type type() const { return type_; }
  36   const char* bytes() const { return bytes_ ? bytes_ : &buf_[0]; }
  37   const base::FilePath& path() const { return path_; }
  38   const GURL& filesystem_url() const { return filesystem_url_; }
  39
  40   // TODO(michaeln): crbug/174200, fully switch to using string uuids.
  41   // Note: Identifying blobs by url is being deprecated, but while
  42   // transitioning, there's a little of both going on in the project.
  43   const std::string& blob_uuid() const { return blob_uuid_; }
  44   const GURL& blob_url() const { return blob_url_; }
  45   uint64 offset() const { return offset_; }
  46   uint64 length() const { return length_; }
  47   const base::Time& expected_modification_time() const {
  48     return expected_modification_time_;
  49   }
  50
  51   // TODO(michaeln): fixup callers to use filesytem_url() and blob_uuid().
  52   const GURL& url() const {
  53     if (type_ == TYPE_FILE_FILESYSTEM)
  54       return filesystem_url_;
  55     return blob_url_;
  56   }
  57
  58   // Sets TYPE_BYTES data. This copies the given data into the element.
  59   void SetToBytes(const char* bytes, int bytes_len) {
  60     type_ = TYPE_BYTES;
  61     buf_.assign(bytes, bytes + bytes_len);
  62     length_ = buf_.size();
  63   }
  64
  65   // Sets TYPE_BYTES data. This does NOT copy the given data and the caller
  66   // should make sure the data is alive when this element is accessed.
  67   void SetToSharedBytes(const char* bytes, int bytes_len) {
  68     type_ = TYPE_BYTES;
  69     bytes_ = bytes;
  70     length_ = bytes_len;
  71   }
  72
  73   // Sets TYPE_FILE data.
  74   void SetToFilePath(const base::FilePath& path) {
  75     SetToFilePathRange(path, 0, kuint64max, base::Time());
  76   }
  77
  78   // Sets TYPE_BLOB data.
  79   void SetToBlobUrl(const GURL& blob_url) {
  80     SetToBlobUrlRange(blob_url, 0, kuint64max);
  81   }
  82   void SetToBlob(const std::string& uuid) {
  83     SetToBlobRange(uuid, 0, kuint64max);
  84   }
  85
  86   // Sets TYPE_FILE data with range.
  87   void SetToFilePathRange(const base::FilePath& path,
  88                           uint64 offset, uint64 length,
  89                           const base::Time& expected_modification_time);
  90
  91   // Sets TYPE_BLOB data with range.
  92   void SetToBlobUrlRange(const GURL& blob_url,
  93                          uint64 offset, uint64 length);
  94   void SetToBlobRange(const std::string& blob_uuid,
  95                       uint64 offset, uint64 length);
  96
  97   // Sets TYPE_FILE_FILESYSTEM with range.
  98   void SetToFileSystemUrlRange(const GURL& filesystem_url,
  99                                uint64 offset, uint64 length,
 100                                const base::Time& expected_modification_time);
 101
 102  private:
 103   Type type_;
 104   std::vector<char> buf_;  // For TYPE_BYTES.
 105   const char* bytes_;  // For TYPE_BYTES.
 106   base::FilePath path_;  // For TYPE_FILE.
 107   GURL filesystem_url_;  // For TYPE_FILE_FILESYSTEM.
 108   GURL blob_url_;
 109   std::string blob_uuid_;
 110   uint64 offset_;
 111   uint64 length_;
 112   base::Time expected_modification_time_;
 113 };
 114
 115 #if defined(UNIT_TEST)
 116 inline bool operator==(const DataElement& a, const DataElement& b) {
 117   if (a.type() != b.type() ||
 118       a.offset() != b.offset() ||
 119       a.length() != b.length())
 120     return false;
 121   switch (a.type()) {
 122     case DataElement::TYPE_BYTES:
 123       return memcmp(a.bytes(), b.bytes(), b.length()) == 0;
 124     case DataElement::TYPE_FILE:
 125       return a.path() == b.path() &&
 126              a.expected_modification_time() == b.expected_modification_time();
 127     case DataElement::TYPE_BLOB:
 128       return a.blob_uuid().empty() ? (a.blob_url() == b.blob_url())
 129                                    : (a.blob_uuid() == b.blob_uuid());
 130     case DataElement::TYPE_FILE_FILESYSTEM:
 131       return a.filesystem_url() == b.filesystem_url();
 132     case DataElement::TYPE_UNKNOWN:
 133       NOTREACHED();
 134       return false;
 135   }
 136   return false;
 137 }
 138
 139 inline bool operator!=(const DataElement& a, const DataElement& b) {
 140   return !(a == b);
 141 }
 142 #endif  // defined(UNIT_TEST)
 143
 144 }  // namespace webkit_common
 145
 146 #endif  // WEBKIT_COMMON_DATA_ELEMENT_H_