diff --git a/api/video/encoded_image.cc b/api/video/encoded_image.cc
index e38bf25b87..53687b455e 100644
--- a/api/video/encoded_image.cc
+++ b/api/video/encoded_image.cc
@@ -39,4 +39,26 @@ void EncodedImage::SetEncodeTime(int64_t encode_start_ms,
   timing_.encode_start_ms = encode_start_ms;
   timing_.encode_finish_ms = encode_finish_ms;
 }
+
+absl::optional<size_t> EncodedImage::SpatialLayerFrameSize(
+    int spatial_index) const {
+  RTC_DCHECK_GE(spatial_index, 0);
+  RTC_DCHECK_LE(spatial_index, spatial_index_.value_or(0));
+
+  auto it = spatial_layer_frame_size_bytes_.find(spatial_index);
+  if (it == spatial_layer_frame_size_bytes_.end()) {
+    return absl::nullopt;
+  }
+
+  return it->second;
+}
+
+void EncodedImage::SetSpatialLayerFrameSize(int spatial_index,
+                                            size_t size_bytes) {
+  RTC_DCHECK_GE(spatial_index, 0);
+  RTC_DCHECK_LE(spatial_index, spatial_index_.value_or(0));
+  RTC_DCHECK_GE(size_bytes, 0);
+  spatial_layer_frame_size_bytes_[spatial_index] = size_bytes;
+}
+
 }  // namespace webrtc
diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h
index 304a798f2b..206ffb6b5f 100644
--- a/api/video/encoded_image.h
+++ b/api/video/encoded_image.h
@@ -12,6 +12,7 @@
 #define API_VIDEO_ENCODED_IMAGE_H_
 
 #include <stdint.h>
+#include <map>
 
 #include "absl/types/optional.h"
 #include "api/video/color_space.h"
@@ -63,6 +64,11 @@ class RTC_EXPORT EncodedImage {
     spatial_index_ = spatial_index;
   }
 
+  // These methods can be used to set/get size of subframe with spatial index
+  // |spatial_index| on encoded frames that consist of multiple spatial layers.
+  absl::optional<size_t> SpatialLayerFrameSize(int spatial_index) const;
+  void SetSpatialLayerFrameSize(int spatial_index, size_t size_bytes);
+
   const webrtc::ColorSpace* ColorSpace() const {
     return color_space_ ? &*color_space_ : nullptr;
   }
@@ -144,6 +150,7 @@ class RTC_EXPORT EncodedImage {
   size_t capacity_;
   uint32_t timestamp_rtp_ = 0;
   absl::optional<int> spatial_index_;
+  std::map<int, size_t> spatial_layer_frame_size_bytes_;
   absl::optional<webrtc::ColorSpace> color_space_;
 };
 
diff --git a/modules/video_coding/encoded_frame.h b/modules/video_coding/encoded_frame.h
index a6bb55bfae..eced69b4ec 100644
--- a/modules/video_coding/encoded_frame.h
+++ b/modules/video_coding/encoded_frame.h
@@ -57,8 +57,11 @@ class VCMEncodedFrame : protected EncodedImage {
   using EncodedImage::set_size;
   using EncodedImage::SetColorSpace;
   using EncodedImage::SetSpatialIndex;
+  using EncodedImage::SetSpatialLayerFrameSize;
   using EncodedImage::SetTimestamp;
   using EncodedImage::size;
+  using EncodedImage::SpatialIndex;
+  using EncodedImage::SpatialLayerFrameSize;
   using EncodedImage::Timestamp;
 
   /**
diff --git a/modules/video_coding/frame_buffer2.cc b/modules/video_coding/frame_buffer2.cc
index a4676623f7..80d1aecb39 100644
--- a/modules/video_coding/frame_buffer2.cc
+++ b/modules/video_coding/frame_buffer2.cc
@@ -737,6 +737,9 @@ EncodedFrame* FrameBuffer::CombineAndDeleteFrames(
   }
   first_frame->VerifyAndAllocate(total_length);
 
+  first_frame->SetSpatialLayerFrameSize(first_frame->id.spatial_layer,
+                                        first_frame->size());
+
   // Spatial index of combined frame is set equal to spatial index of its top
   // spatial layer.
   first_frame->SetSpatialIndex(last_frame->id.spatial_layer);
@@ -751,6 +754,8 @@ EncodedFrame* FrameBuffer::CombineAndDeleteFrames(
   uint8_t* buffer = first_frame->data() + first_frame->size();
   for (size_t i = 1; i < frames.size(); ++i) {
     EncodedFrame* next_frame = frames[i];
+    first_frame->SetSpatialLayerFrameSize(next_frame->id.spatial_layer,
+                                          next_frame->size());
     memcpy(buffer, next_frame->data(), next_frame->size());
     buffer += next_frame->size();
     delete next_frame;
diff --git a/modules/video_coding/frame_buffer2_unittest.cc b/modules/video_coding/frame_buffer2_unittest.cc
index f1308aca40..083b89b52a 100644
--- a/modules/video_coding/frame_buffer2_unittest.cc
+++ b/modules/video_coding/frame_buffer2_unittest.cc
@@ -159,6 +159,7 @@ class TestFrameBuffer2 : public ::testing::Test {
                                                int64_t ts_ms,
                                                bool inter_layer_predicted,
                                                bool last_spatial_layer,
+                                               size_t frame_size_bytes,
                                                T... refs) {
     static_assert(sizeof...(refs) <= kMaxReferences,
                   "To many references specified for EncodedFrame.");
@@ -174,8 +175,8 @@ class TestFrameBuffer2 : public ::testing::Test {
     frame->inter_layer_predicted = inter_layer_predicted;
     frame->is_last_spatial_layer = last_spatial_layer;
     // Add some data to buffer.
-    frame->VerifyAndAllocate(kFrameSize);
-    frame->set_size(kFrameSize);
+    frame->VerifyAndAllocate(frame_size_bytes);
+    frame->set_size(frame_size_bytes);
     for (size_t r = 0; r < references.size(); ++r)
       frame->references[r] = references[r];
     return frame;
@@ -187,15 +188,16 @@ class TestFrameBuffer2 : public ::testing::Test {
                   int64_t ts_ms,
                   bool inter_layer_predicted,
                   bool last_spatial_layer,
+                  size_t frame_size_bytes,
                   T... refs) {
-    return buffer_->InsertFrame(CreateFrame(picture_id, spatial_layer, ts_ms,
-                                            inter_layer_predicted,
-                                            last_spatial_layer, refs...));
+    return buffer_->InsertFrame(
+        CreateFrame(picture_id, spatial_layer, ts_ms, inter_layer_predicted,
+                    last_spatial_layer, frame_size_bytes, refs...));
   }
 
   int InsertNackedFrame(uint16_t picture_id, int64_t ts_ms) {
     std::unique_ptr<FrameObjectFake> frame =
-        CreateFrame(picture_id, 0, ts_ms, false, true);
+        CreateFrame(picture_id, 0, ts_ms, false, true, kFrameSize);
     frame->set_delayed_by_retransmission(true);
     return buffer_->InsertFrame(std::move(frame));
   }
@@ -277,6 +279,15 @@ class TestFrameBuffer2 : public ::testing::Test {
   rtc::CriticalSection crit_;
 };
 
+// From https://en.cppreference.com/w/cpp/language/static: "If ... a constexpr
+// static data member (since C++11) is odr-used, a definition at namespace scope
+// is still required... This definition is deprecated for constexpr data members
+// since C++17."
+// kFrameSize is odr-used since it is passed by reference to EXPECT_EQ().
+#if __cplusplus < 201703L
+constexpr size_t TestFrameBuffer2::kFrameSize;
+#endif
+
 // Following tests are timing dependent. Either the timeouts have to
 // be increased by a large margin, which would slow down all trybots,
 // or we disable them for the very slow ones, like we do here.
@@ -286,7 +297,7 @@ TEST_F(TestFrameBuffer2, WaitForFrame) {
   uint32_t ts = Rand();
 
   ExtractFrame(50);
-  InsertFrame(pid, 0, ts, false, true);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
   CheckFrame(0, pid, 0);
 }
 
@@ -294,8 +305,8 @@ TEST_F(TestFrameBuffer2, OneSuperFrame) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, false);
-  InsertFrame(pid, 1, ts, true, true);
+  InsertFrame(pid, 0, ts, false, false, kFrameSize);
+  InsertFrame(pid, 1, ts, true, true, kFrameSize);
   ExtractFrame();
 
   CheckFrame(0, pid, 1);
@@ -320,8 +331,8 @@ TEST_F(TestFrameBuffer2, DISABLED_OneUnorderedSuperFrame) {
   uint32_t ts = Rand();
 
   ExtractFrame(50);
-  InsertFrame(pid, 1, ts, true, true);
-  InsertFrame(pid, 0, ts, false, false);
+  InsertFrame(pid, 1, ts, true, true, kFrameSize);
+  InsertFrame(pid, 0, ts, false, false, kFrameSize);
   ExtractFrame();
 
   CheckFrame(0, pid, 0);
@@ -332,14 +343,16 @@ TEST_F(TestFrameBuffer2, DISABLED_OneLayerStreamReordered) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, true);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
   ExtractFrame();
   CheckFrame(0, pid, 0);
   for (int i = 1; i < 10; i += 2) {
     ExtractFrame(50);
-    InsertFrame(pid + i + 1, 0, ts + (i + 1) * kFps10, false, true, pid + i);
+    InsertFrame(pid + i + 1, 0, ts + (i + 1) * kFps10, false, true, kFrameSize,
+                pid + i);
     clock_.AdvanceTimeMilliseconds(kFps10);
-    InsertFrame(pid + i, 0, ts + i * kFps10, false, true, pid + i - 1);
+    InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
+                pid + i - 1);
     clock_.AdvanceTimeMilliseconds(kFps10);
     ExtractFrame();
     CheckFrame(i, pid + i, 0);
@@ -357,9 +370,9 @@ TEST_F(TestFrameBuffer2, MissingFrame) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, true);
-  InsertFrame(pid + 2, 0, ts, false, true, pid);
-  InsertFrame(pid + 3, 0, ts, false, true, pid + 1, pid + 2);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
+  InsertFrame(pid + 2, 0, ts, false, true, kFrameSize, pid);
+  InsertFrame(pid + 3, 0, ts, false, true, kFrameSize, pid + 1, pid + 2);
   ExtractFrame();
   ExtractFrame();
   ExtractFrame();
@@ -373,11 +386,12 @@ TEST_F(TestFrameBuffer2, OneLayerStream) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, true);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
   ExtractFrame();
   CheckFrame(0, pid, 0);
   for (int i = 1; i < 10; ++i) {
-    InsertFrame(pid + i, 0, ts + i * kFps10, false, true, pid + i - 1);
+    InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
+                pid + i - 1);
     ExtractFrame();
     clock_.AdvanceTimeMilliseconds(kFps10);
     CheckFrame(i, pid + i, 0);
@@ -388,13 +402,13 @@ TEST_F(TestFrameBuffer2, DropTemporalLayerSlowDecoder) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, true);
-  InsertFrame(pid + 1, 0, ts + kFps20, false, true, pid);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
+  InsertFrame(pid + 1, 0, ts + kFps20, false, true, kFrameSize, pid);
   for (int i = 2; i < 10; i += 2) {
     uint32_t ts_tl0 = ts + i / 2 * kFps10;
-    InsertFrame(pid + i, 0, ts_tl0, false, true, pid + i - 2);
-    InsertFrame(pid + i + 1, 0, ts_tl0 + kFps20, false, true, pid + i,
-                pid + i - 1);
+    InsertFrame(pid + i, 0, ts_tl0, false, true, kFrameSize, pid + i - 2);
+    InsertFrame(pid + i + 1, 0, ts_tl0 + kFps20, false, true, kFrameSize,
+                pid + i, pid + i - 1);
   }
 
   for (int i = 0; i < 10; ++i) {
@@ -418,11 +432,11 @@ TEST_F(TestFrameBuffer2, InsertLateFrame) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, true);
+  InsertFrame(pid, 0, ts, false, true, kFrameSize);
   ExtractFrame();
-  InsertFrame(pid + 2, 0, ts, false, true);
+  InsertFrame(pid + 2, 0, ts, false, true, kFrameSize);
   ExtractFrame();
-  InsertFrame(pid + 1, 0, ts, false, true, pid);
+  InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid);
   ExtractFrame();
 
   CheckFrame(0, pid, 0);
@@ -441,7 +455,7 @@ TEST_F(TestFrameBuffer2, ProtectionModeNackFEC) {
   InsertNackedFrame(pid, ts);
   InsertNackedFrame(pid + 1, ts + 100);
   InsertNackedFrame(pid + 2, ts + 200);
-  InsertFrame(pid + 3, 0, ts + 300, false, true);
+  InsertFrame(pid + 3, 0, ts + 300, false, true, kFrameSize);
   ExtractFrame();
   ExtractFrame();
   ExtractFrame();
@@ -462,7 +476,7 @@ TEST_F(TestFrameBuffer2, ProtectionModeNack) {
   InsertNackedFrame(pid, ts);
   InsertNackedFrame(pid + 1, ts + 100);
   InsertNackedFrame(pid + 2, ts + 200);
-  InsertFrame(pid + 3, 0, ts + 300, false, true);
+  InsertFrame(pid + 3, 0, ts + 300, false, true, kFrameSize);
   ExtractFrame();
   ExtractFrame();
   ExtractFrame();
@@ -476,45 +490,51 @@ TEST_F(TestFrameBuffer2, NoContinuousFrame) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  EXPECT_EQ(-1, InsertFrame(pid + 1, 0, ts, false, true, pid));
+  EXPECT_EQ(-1, InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid));
 }
 
 TEST_F(TestFrameBuffer2, LastContinuousFrameSingleLayer) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true));
-  EXPECT_EQ(pid, InsertFrame(pid + 2, 0, ts, false, true, pid + 1));
-  EXPECT_EQ(pid + 2, InsertFrame(pid + 1, 0, ts, false, true, pid));
-  EXPECT_EQ(pid + 2, InsertFrame(pid + 4, 0, ts, false, true, pid + 3));
-  EXPECT_EQ(pid + 5, InsertFrame(pid + 5, 0, ts, false, true));
+  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true, kFrameSize));
+  EXPECT_EQ(pid, InsertFrame(pid + 2, 0, ts, false, true, kFrameSize, pid + 1));
+  EXPECT_EQ(pid + 2, InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid));
+  EXPECT_EQ(pid + 2,
+            InsertFrame(pid + 4, 0, ts, false, true, kFrameSize, pid + 3));
+  EXPECT_EQ(pid + 5, InsertFrame(pid + 5, 0, ts, false, true, kFrameSize));
 }
 
 TEST_F(TestFrameBuffer2, LastContinuousFrameTwoLayers) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, false));
-  EXPECT_EQ(pid, InsertFrame(pid, 1, ts, true, true));
-  EXPECT_EQ(pid, InsertFrame(pid + 1, 1, ts, true, true, pid));
-  EXPECT_EQ(pid, InsertFrame(pid + 2, 0, ts, false, false, pid + 1));
-  EXPECT_EQ(pid, InsertFrame(pid + 2, 1, ts, true, true, pid + 1));
-  EXPECT_EQ(pid, InsertFrame(pid + 3, 0, ts, false, false, pid + 2));
-  EXPECT_EQ(pid + 3, InsertFrame(pid + 1, 0, ts, false, false, pid));
-  EXPECT_EQ(pid + 3, InsertFrame(pid + 3, 1, ts, true, true, pid + 2));
+  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, false, kFrameSize));
+  EXPECT_EQ(pid, InsertFrame(pid, 1, ts, true, true, kFrameSize));
+  EXPECT_EQ(pid, InsertFrame(pid + 1, 1, ts, true, true, kFrameSize, pid));
+  EXPECT_EQ(pid,
+            InsertFrame(pid + 2, 0, ts, false, false, kFrameSize, pid + 1));
+  EXPECT_EQ(pid, InsertFrame(pid + 2, 1, ts, true, true, kFrameSize, pid + 1));
+  EXPECT_EQ(pid,
+            InsertFrame(pid + 3, 0, ts, false, false, kFrameSize, pid + 2));
+  EXPECT_EQ(pid + 3,
+            InsertFrame(pid + 1, 0, ts, false, false, kFrameSize, pid));
+  EXPECT_EQ(pid + 3,
+            InsertFrame(pid + 3, 1, ts, true, true, kFrameSize, pid + 2));
 }
 
 TEST_F(TestFrameBuffer2, PictureIdJumpBack) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true));
-  EXPECT_EQ(pid + 1, InsertFrame(pid + 1, 0, ts + 1, false, true, pid));
+  EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true, kFrameSize));
+  EXPECT_EQ(pid + 1,
+            InsertFrame(pid + 1, 0, ts + 1, false, true, kFrameSize, pid));
   ExtractFrame();
   CheckFrame(0, pid, 0);
 
   // Jump back in pid but increase ts.
-  EXPECT_EQ(pid - 1, InsertFrame(pid - 1, 0, ts + 2, false, true));
+  EXPECT_EQ(pid - 1, InsertFrame(pid - 1, 0, ts + 2, false, true, kFrameSize));
   ExtractFrame();
   ExtractFrame();
   CheckFrame(1, pid - 1, 0);
@@ -549,42 +569,42 @@ TEST_F(TestFrameBuffer2, StatsCallback) {
 }
 
 TEST_F(TestFrameBuffer2, ForwardJumps) {
-  EXPECT_EQ(5453, InsertFrame(5453, 0, 1, false, true));
+  EXPECT_EQ(5453, InsertFrame(5453, 0, 1, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(5454, InsertFrame(5454, 0, 1, false, true, 5453));
+  EXPECT_EQ(5454, InsertFrame(5454, 0, 1, false, true, kFrameSize, 5453));
   ExtractFrame();
-  EXPECT_EQ(15670, InsertFrame(15670, 0, 1, false, true));
+  EXPECT_EQ(15670, InsertFrame(15670, 0, 1, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(29804, InsertFrame(29804, 0, 1, false, true));
+  EXPECT_EQ(29804, InsertFrame(29804, 0, 1, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(29805, InsertFrame(29805, 0, 1, false, true, 29804));
+  EXPECT_EQ(29805, InsertFrame(29805, 0, 1, false, true, kFrameSize, 29804));
   ExtractFrame();
-  EXPECT_EQ(29806, InsertFrame(29806, 0, 1, false, true, 29805));
+  EXPECT_EQ(29806, InsertFrame(29806, 0, 1, false, true, kFrameSize, 29805));
   ExtractFrame();
-  EXPECT_EQ(33819, InsertFrame(33819, 0, 1, false, true));
+  EXPECT_EQ(33819, InsertFrame(33819, 0, 1, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(41248, InsertFrame(41248, 0, 1, false, true));
+  EXPECT_EQ(41248, InsertFrame(41248, 0, 1, false, true, kFrameSize));
   ExtractFrame();
 }
 
 TEST_F(TestFrameBuffer2, DuplicateFrames) {
-  EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true));
+  EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true));
+  EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true, kFrameSize));
 }
 
 // TODO(philipel): implement more unittests related to invalid references.
 TEST_F(TestFrameBuffer2, InvalidReferences) {
-  EXPECT_EQ(-1, InsertFrame(0, 0, 1000, false, true, 2));
-  EXPECT_EQ(1, InsertFrame(1, 0, 2000, false, true));
+  EXPECT_EQ(-1, InsertFrame(0, 0, 1000, false, true, kFrameSize, 2));
+  EXPECT_EQ(1, InsertFrame(1, 0, 2000, false, true, kFrameSize));
   ExtractFrame();
-  EXPECT_EQ(2, InsertFrame(2, 0, 3000, false, true, 1));
+  EXPECT_EQ(2, InsertFrame(2, 0, 3000, false, true, kFrameSize, 1));
 }
 
 TEST_F(TestFrameBuffer2, KeyframeRequired) {
-  EXPECT_EQ(1, InsertFrame(1, 0, 1000, false, true));
-  EXPECT_EQ(2, InsertFrame(2, 0, 2000, false, true, 1));
-  EXPECT_EQ(3, InsertFrame(3, 0, 3000, false, true));
+  EXPECT_EQ(1, InsertFrame(1, 0, 1000, false, true, kFrameSize));
+  EXPECT_EQ(2, InsertFrame(2, 0, 2000, false, true, kFrameSize, 1));
+  EXPECT_EQ(3, InsertFrame(3, 0, 3000, false, true, kFrameSize));
   ExtractFrame();
   ExtractFrame(0, true);
   ExtractFrame();
@@ -598,37 +618,39 @@ TEST_F(TestFrameBuffer2, KeyframeClearsFullBuffer) {
   const int kMaxBufferSize = 600;
 
   for (int i = 1; i <= kMaxBufferSize; ++i)
-    EXPECT_EQ(-1, InsertFrame(i, 0, i * 1000, false, true, i - 1));
+    EXPECT_EQ(-1, InsertFrame(i, 0, i * 1000, false, true, kFrameSize, i - 1));
   ExtractFrame();
   CheckNoFrame(0);
 
   EXPECT_EQ(kMaxBufferSize + 1,
             InsertFrame(kMaxBufferSize + 1, 0, (kMaxBufferSize + 1) * 1000,
-                        false, true));
+                        false, true, kFrameSize));
   ExtractFrame();
   CheckFrame(1, kMaxBufferSize + 1, 0);
 }
 
 TEST_F(TestFrameBuffer2, DontUpdateOnUndecodableFrame) {
-  InsertFrame(1, 0, 0, false, true);
+  InsertFrame(1, 0, 0, false, true, kFrameSize);
   ExtractFrame(0, true);
-  InsertFrame(3, 0, 0, false, true, 2, 0);
-  InsertFrame(3, 0, 0, false, true, 0);
-  InsertFrame(2, 0, 0, false, true);
+  InsertFrame(3, 0, 0, false, true, kFrameSize, 2, 0);
+  InsertFrame(3, 0, 0, false, true, kFrameSize, 0);
+  InsertFrame(2, 0, 0, false, true, kFrameSize);
   ExtractFrame(0, true);
   ExtractFrame(0, true);
 }
 
 TEST_F(TestFrameBuffer2, DontDecodeOlderTimestamp) {
-  InsertFrame(2, 0, 1, false, true);
-  InsertFrame(1, 0, 2, false, true);  // Older picture id but newer timestamp.
+  InsertFrame(2, 0, 1, false, true, kFrameSize);
+  InsertFrame(1, 0, 2, false, true,
+              kFrameSize);  // Older picture id but newer timestamp.
   ExtractFrame(0);
   ExtractFrame(0);
   CheckFrame(0, 1, 0);
   CheckNoFrame(1);
 
-  InsertFrame(3, 0, 4, false, true);
-  InsertFrame(4, 0, 3, false, true);  // Newer picture id but older timestamp.
+  InsertFrame(3, 0, 4, false, true, kFrameSize);
+  InsertFrame(4, 0, 3, false, true,
+              kFrameSize);  // Newer picture id but older timestamp.
   ExtractFrame(0);
   ExtractFrame(0);
   CheckFrame(2, 3, 0);
@@ -639,29 +661,33 @@ TEST_F(TestFrameBuffer2, CombineFramesToSuperframe) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, false);
-  InsertFrame(pid, 1, ts, true, true);
+  InsertFrame(pid, 0, ts, false, false, kFrameSize);
+  InsertFrame(pid, 1, ts, true, true, 2 * kFrameSize);
   ExtractFrame(0);
   ExtractFrame(0);
   CheckFrame(0, pid, 1);
   CheckNoFrame(1);
   // Two frames should be combined and returned together.
-  CheckFrameSize(0, kFrameSize * 2);
+  CheckFrameSize(0, 3 * kFrameSize);
+
+  EXPECT_EQ(frames_[0]->SpatialIndex(), 1);
+  EXPECT_EQ(frames_[0]->SpatialLayerFrameSize(0), kFrameSize);
+  EXPECT_EQ(frames_[0]->SpatialLayerFrameSize(1), 2 * kFrameSize);
 }
 
 TEST_F(TestFrameBuffer2, HigherSpatialLayerNonDecodable) {
   uint16_t pid = Rand();
   uint32_t ts = Rand();
 
-  InsertFrame(pid, 0, ts, false, false);
-  InsertFrame(pid, 1, ts, true, true);
+  InsertFrame(pid, 0, ts, false, false, kFrameSize);
+  InsertFrame(pid, 1, ts, true, true, kFrameSize);
 
   ExtractFrame(0);
   CheckFrame(0, pid, 1);
 
-  InsertFrame(pid + 1, 1, ts + kFps20, false, true, pid);
-  InsertFrame(pid + 2, 0, ts + kFps10, false, false, pid);
-  InsertFrame(pid + 2, 1, ts + kFps10, true, true, pid + 1);
+  InsertFrame(pid + 1, 1, ts + kFps20, false, true, kFrameSize, pid);
+  InsertFrame(pid + 2, 0, ts + kFps10, false, false, kFrameSize, pid);
+  InsertFrame(pid + 2, 1, ts + kFps10, true, true, kFrameSize, pid + 1);
 
   clock_.AdvanceTimeMilliseconds(1000);
   // Frame pid+1 is decodable but too late.