extra/chromium/patches/chromium-sql-make-VirtualCursor-standard-layout-type.patch

   1 diff --git a/sql/recover_module/btree.cc b/sql/recover_module/btree.cc
   2 index 9ecaafe..839318a 100644
   3 --- a/sql/recover_module/btree.cc
   4 +++ b/sql/recover_module/btree.cc
   5 @@ -135,16 +135,25 @@ static_assert(std::is_trivially_destructible<LeafPageDecoder>::value,
   6                "Move the destructor to the .cc file if it's non-trival");
   7  #endif  // !DCHECK_IS_ON()
   8
   9 -LeafPageDecoder::LeafPageDecoder(DatabasePageReader* db_reader) noexcept
  10 -    : page_id_(db_reader->page_id()),
  11 -      db_reader_(db_reader),
  12 -      cell_count_(ComputeCellCount(db_reader)),
  13 -      next_read_index_(0),
  14 -      last_record_size_(0) {
  15 +void LeafPageDecoder::Initialize(DatabasePageReader* db_reader) {
  16 +  DCHECK(db_reader);
  17    DCHECK(IsOnValidPage(db_reader));
  18 +  page_id_ = db_reader->page_id();
  19 +  db_reader_ = db_reader;
  20 +  cell_count_ = ComputeCellCount(db_reader);
  21 +  next_read_index_ = 0;
  22 +  last_record_size_ = 0;
  23    DCHECK(DatabasePageReader::IsValidPageId(page_id_));
  24  }
  25
  26 +void LeafPageDecoder::Reset() {
  27 +  db_reader_ = nullptr;
  28 +  page_id_ = 0;
  29 +  cell_count_ = 0;
  30 +  next_read_index_ = 0;
  31 +  last_record_size_ = 0;
  32 +}
  33 +
  34  bool LeafPageDecoder::TryAdvance() {
  35    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  36    DCHECK(CanAdvance());
  37 diff --git a/sql/recover_module/btree.h b/sql/recover_module/btree.h
  38 index d76d076..33114b0 100644
  39 --- a/sql/recover_module/btree.h
  40 +++ b/sql/recover_module/btree.h
  41 @@ -102,7 +102,7 @@ class LeafPageDecoder {
  42    //
  43    // |db_reader| must have been used to read an inner page of a table B-tree.
  44    // |db_reader| must outlive this instance.
  45 -  explicit LeafPageDecoder(DatabasePageReader* db_reader) noexcept;
  46 +  explicit LeafPageDecoder() noexcept = default;
  47    ~LeafPageDecoder() noexcept = default;
  48
  49    LeafPageDecoder(const LeafPageDecoder&) = delete;
  50 @@ -150,6 +150,15 @@ class LeafPageDecoder {
  51    // read as long as CanAdvance() returns true.
  52    bool TryAdvance();
  53
  54 +  // Initialize with DatabasePageReader
  55 +  void Initialize(DatabasePageReader* db_reader);
  56 +
  57 +  // Reset internal DatabasePageReader
  58 +  void Reset();
  59 +
  60 +  // True if DatabasePageReader is valid
  61 +  bool IsValid() { return (db_reader_ != nullptr); }
  62 +
  63    // True if the given reader may point to an inner page in a table B-tree.
  64    //
  65    // The last ReadPage() call on |db_reader| must have succeeded.
  66 @@ -163,14 +172,14 @@ class LeafPageDecoder {
  67    static int ComputeCellCount(DatabasePageReader* db_reader);
  68
  69    // The number of the B-tree page this reader is reading.
  70 -  const int64_t page_id_;
  71 +  int64_t page_id_;
  72    // Used to read the tree page.
  73    //
  74    // Raw pointer usage is acceptable because this instance's owner is expected
  75    // to ensure that the DatabasePageReader outlives this.
  76 -  DatabasePageReader* const db_reader_;
  77 +  DatabasePageReader* db_reader_;
  78    // Caches the ComputeCellCount() value for this reader's page.
  79 -  const int cell_count_ = ComputeCellCount(db_reader_);
  80 +  int cell_count_;
  81
  82    // The reader's cursor state.
  83    //
  84 diff --git a/sql/recover_module/cursor.cc b/sql/recover_module/cursor.cc
  85 index 0029ff9..42548bc 100644
  86 --- a/sql/recover_module/cursor.cc
  87 +++ b/sql/recover_module/cursor.cc
  88 @@ -26,7 +26,7 @@ VirtualCursor::~VirtualCursor() {
  89  int VirtualCursor::First() {
  90    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  91    inner_decoders_.clear();
  92 -  leaf_decoder_ = nullptr;
  93 +  leaf_decoder_.Reset();
  94
  95    AppendPageDecoder(table_->root_page_id());
  96    return Next();
  97 @@ -36,18 +36,18 @@ int VirtualCursor::Next() {
  98    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  99    record_reader_.Reset();
 100
 101 -  while (!inner_decoders_.empty() || leaf_decoder_.get()) {
 102 -    if (leaf_decoder_.get()) {
 103 -      if (!leaf_decoder_->CanAdvance()) {
 104 +  while (!inner_decoders_.empty() || leaf_decoder_.IsValid()) {
 105 +    if (leaf_decoder_.IsValid()) {
 106 +      if (!leaf_decoder_.CanAdvance()) {
 107          // The leaf has been exhausted. Remove it from the DFS stack.
 108 -        leaf_decoder_ = nullptr;
 109 +        leaf_decoder_.Reset();
 110          continue;
 111        }
 112 -      if (!leaf_decoder_->TryAdvance())
 113 +      if (!leaf_decoder_.TryAdvance())
 114          continue;
 115
 116 -      if (!payload_reader_.Initialize(leaf_decoder_->last_record_size(),
 117 -                                      leaf_decoder_->last_record_offset())) {
 118 +      if (!payload_reader_.Initialize(leaf_decoder_.last_record_size(),
 119 +                                      leaf_decoder_.last_record_offset())) {
 120          continue;
 121        }
 122        if (!record_reader_.Initialize())
 123 @@ -99,13 +99,13 @@ int VirtualCursor::ReadColumn(int column_index,
 124  int64_t VirtualCursor::RowId() {
 125    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 126    DCHECK(record_reader_.IsInitialized());
 127 -  DCHECK(leaf_decoder_.get());
 128 -  return leaf_decoder_->last_record_rowid();
 129 +  DCHECK(leaf_decoder_.IsValid());
 130 +  return leaf_decoder_.last_record_rowid();
 131  }
 132
 133  void VirtualCursor::AppendPageDecoder(int page_id) {
 134    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 135 -  DCHECK(leaf_decoder_.get() == nullptr)
 136 +  DCHECK(!leaf_decoder_.IsValid())
 137        << __func__
 138        << " must only be called when the current path has no leaf decoder";
 139
 140 @@ -113,7 +113,7 @@ void VirtualCursor::AppendPageDecoder(int page_id) {
 141      return;
 142
 143    if (LeafPageDecoder::IsOnValidPage(&db_reader_)) {
 144 -    leaf_decoder_ = std::make_unique<LeafPageDecoder>(&db_reader_);
 145 +    leaf_decoder_.Initialize(&db_reader_);
 146      return;
 147    }
 148
 149 diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h
 150 index afcd690..b15c31d 100644
 151 --- a/sql/recover_module/cursor.h
 152 +++ b/sql/recover_module/cursor.h
 153 @@ -129,7 +129,7 @@ class VirtualCursor {
 154    std::vector<std::unique_ptr<InnerPageDecoder>> inner_decoders_;
 155
 156    // Decodes the leaf page containing records.
 157 -  std::unique_ptr<LeafPageDecoder> leaf_decoder_;
 158 +  LeafPageDecoder leaf_decoder_;
 159
 160    SEQUENCE_CHECKER(sequence_checker_);
 161  };
 162 diff --git a/sql/recover_module/pager.cc b/sql/recover_module/pager.cc
 163 index 58e75de..5fe9620 100644
 164 --- a/sql/recover_module/pager.cc
 165 +++ b/sql/recover_module/pager.cc
 166 @@ -23,8 +23,7 @@ static_assert(DatabasePageReader::kMaxPageId <= std::numeric_limits<int>::max(),
 167                "ints are not appropriate for representing page IDs");
 168
 169  DatabasePageReader::DatabasePageReader(VirtualTable* table)
 170 -    : page_data_(std::make_unique<uint8_t[]>(table->page_size())),
 171 -      table_(table) {
 172 +    : page_data_(), table_(table) {
 173    DCHECK(table != nullptr);
 174    DCHECK(IsValidPageSize(table->page_size()));
 175  }
 176 @@ -57,8 +56,8 @@ int DatabasePageReader::ReadPage(int page_id) {
 177                      std::numeric_limits<int64_t>::max(),
 178                  "The |read_offset| computation above may overflow");
 179
 180 -  int sqlite_status =
 181 -      RawRead(sqlite_file, read_size, read_offset, page_data_.get());
 182 +  int sqlite_status = RawRead(sqlite_file, read_size, read_offset,
 183 +                              const_cast<uint8_t*>(page_data_.data()));
 184
 185    // |page_id_| needs to be set to kInvalidPageId if the read failed.
 186    // Otherwise, future ReadPage() calls with the previous |page_id_| value
 187 diff --git a/sql/recover_module/pager.h b/sql/recover_module/pager.h
 188 index 0e388dd..99314e3 100644
 189 --- a/sql/recover_module/pager.h
 190 +++ b/sql/recover_module/pager.h
 191 @@ -5,6 +5,7 @@
 192  #ifndef SQL_RECOVER_MODULE_PAGER_H_
 193  #define SQL_RECOVER_MODULE_PAGER_H_
 194
 195 +#include <array>
 196  #include <cstdint>
 197  #include <memory>
 198
 199 @@ -70,7 +71,7 @@ class DatabasePageReader {
 200      DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 201      DCHECK_NE(page_id_, kInvalidPageId)
 202          << "Successful ReadPage() required before accessing pager state";
 203 -    return page_data_.get();
 204 +    return page_data_.data();
 205    }
 206
 207    // The number of bytes in the page read by the last ReadPage() call.
 208 @@ -137,7 +138,7 @@ class DatabasePageReader {
 209    int page_id_ = kInvalidPageId;
 210    // Stores the bytes of the last page successfully read by ReadPage().
 211    // The content is undefined if the last call to ReadPage() did not succeed.
 212 -  const std::unique_ptr<uint8_t[]> page_data_;
 213 +  const std::array<uint8_t, kMaxPageSize> page_data_;
 214    // Raw pointer usage is acceptable because this instance's owner is expected
 215    // to ensure that the VirtualTable outlives this.
 216    VirtualTable* const table_;