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   // Sets TYPE_BYTES data. This copies the given data into the element.
  52   void SetToBytes(const char* bytes, int bytes_len) {
  53     type_ = TYPE_BYTES;
  54     buf_.assign(bytes, bytes + bytes_len);
  55     length_ = buf_.size();
  56   }
  57
  58   // Sets TYPE_BYTES data. This does NOT copy the given data and the caller
  59   // should make sure the data is alive when this element is accessed.
  60   void SetToSharedBytes(const char* bytes, int bytes_len) {
  61     type_ = TYPE_BYTES;
  62     bytes_ = bytes;
  63     length_ = bytes_len;
  64   }
  65
  66   // Sets TYPE_FILE data.
  67   void SetToFilePath(const base::FilePath& path) {
  68     SetToFilePathRange(path, 0, kuint64max, base::Time());
  69   }
  70
  71   // Sets TYPE_BLOB data.
  72   void SetToBlobUrl(const GURL& blob_url) {
  73     SetToBlobUrlRange(blob_url, 0, kuint64max);
  74   }
  75   void SetToBlob(const std::string& uuid) {
  76     SetToBlobRange(uuid, 0, kuint64max);
  77   }
  78
  79   // Sets TYPE_FILE data with range.
  80   void SetToFilePathRange(const base::FilePath& path,
  81                           uint64 offset, uint64 length,
  82                           const base::Time& expected_modification_time);
  83
  84   // Sets TYPE_BLOB data with range.
  85   void SetToBlobUrlRange(const GURL& blob_url,
  86                          uint64 offset, uint64 length);
  87   void SetToBlobRange(const std::string& blob_uuid,
  88                       uint64 offset, uint64 length);
  89
  90   // Sets TYPE_FILE_FILESYSTEM with range.
  91   void SetToFileSystemUrlRange(const GURL& filesystem_url,
  92                                uint64 offset, uint64 length,
  93                                const base::Time& expected_modification_time);
  94
  95  private:
  96   Type type_;
  97   std::vector<char> buf_;  // For TYPE_BYTES.
  98   const char* bytes_;  // For TYPE_BYTES.
  99   base::FilePath path_;  // For TYPE_FILE.
 100   GURL filesystem_url_;  // For TYPE_FILE_FILESYSTEM.
 101   GURL blob_url_;
 102   std::string blob_uuid_;
 103   uint64 offset_;
 104   uint64 length_;
 105   base::Time expected_modification_time_;
 106 };
 107
 108 #if defined(UNIT_TEST)
 109 inline bool operator==(const DataElement& a, const DataElement& b) {
 110   if (a.type() != b.type() ||
 111       a.offset() != b.offset() ||
 112       a.length() != b.length())
 113     return false;
 114   switch (a.type()) {
 115     case DataElement::TYPE_BYTES:
 116       return memcmp(a.bytes(), b.bytes(), b.length()) == 0;
 117     case DataElement::TYPE_FILE:
 118       return a.path() == b.path() &&
 119              a.expected_modification_time() == b.expected_modification_time();
 120     case DataElement::TYPE_BLOB:
 121       return a.blob_uuid().empty() ? (a.blob_url() == b.blob_url())
 122                                    : (a.blob_uuid() == b.blob_uuid());
 123     case DataElement::TYPE_FILE_FILESYSTEM:
 124       return a.filesystem_url() == b.filesystem_url();
 125     case DataElement::TYPE_UNKNOWN:
 126       NOTREACHED();
 127       return false;
 128   }
 129   return false;
 130 }
 131
 132 inline bool operator!=(const DataElement& a, const DataElement& b) {
 133   return !(a == b);
 134 }
 135 #endif  // defined(UNIT_TEST)
 136
 137 }  // namespace webkit_common
 138
 139 #endif  // WEBKIT_COMMON_DATA_ELEMENT_H_