AI Code Gen Fuckups

@@ -3,6 +3,7 @@ Utility functions for file system operations and context reading. """  import os+import re from pathlib import Path from typing import List, Optional @@ -62,9 +63,243 @@ def _append_file_content(file_path: Path, contents_list: List[str], max_lines: i                 print(f"Skipping {file_path} (more than {max_lines} lines)")                 return             -            file_content = "".join(lines)-            contents_list.append(f"--- File: {file_path} ---\n{file_content}\n")+            formatted_lines = []+            # Determine the maximum number of digits for line numbers for consistent padding+            max_line_num_digits = len(str(len(lines)))++            for i, line in enumerate(lines):+                # Prepend line number with padding, followed by the content+                formatted_lines.append(f"{i+1:>{max_line_num_digits}} {line.rstrip()}\n")+            +            file_content = "".join(formatted_lines)+            contents_list.append(f"--- File: {file_path} ---\n{file_content}")     except UnicodeDecodeError:         print(f"Skipping {file_path} (binary or non-UTF-8 content)")     except Exception as e:         print(f"Skipping {file_path} due to error: {e}")++def format_markdown(text: str) -> str:++    """++    Adds ANSI escape codes and ASCII box drawing characters to text for better readability in the terminal.++    Focuses on clearly delineating comments and coloring code blocks.++    """++    if not text:++        return text++++    # Color for code blocks and inline code++    CODE_COLOR = '\033[96m' # Cyan for inline, will use yellow for blocks++    BLOCK_CODE_COLOR = '\033[93m' # Yellow for blocks++    RESET_COLOR = '\033[0m'++    ++    # Color and box characters for comments (blockquotes)++    COMMENT_COLOR = '\033[35m'++    BOX_TOP_LEFT = '┌'++    BOX_HORIZONTAL = '─'++    BOX_VERTICAL = '│'++    BOX_BOTTOM_LEFT = '└'++++    code_blocks = []++    ++    def extract_code_block(match):++        # Store the actual code content, not the ``` markers++        code_blocks.append(match.group(1).strip())++        return f"__CODE_BLOCK_{len(code_blocks)-1}__"++++        # Extract code blocks first to prevent markdown inside them from being processed++++        text = re.sub(r'```(?:[^\\n]*\\n)?(.*?)```', extract_code_block, text, flags=re.DOTALL)++++        ++++        # Inline code (no backticks, just colored)++++        text = re.sub(r'`([^`\\n]+)`', r' ' + CODE_COLOR + r'\g<1>' + RESET_COLOR + r' ', text)++++    ++++        # Process blockquotes/comments with ASCII box drawing characters++++        def format_blockquote(match):++++            full_blockquote_content = match.group(1)++++            lines = full_blockquote_content.strip().split('\\n')++++            ++++            cleaned_lines = [line.lstrip('> ') for line in lines]++++    ++++            max_line_width = 0++++            if cleaned_lines:++++                max_line_width = max(len(line) for line in cleaned_lines)++++            ++++            box_width = max_line_width + 2++++            min_box_width = 5++++            if box_width < min_box_width:++++                box_width = min_box_width++++    ++++            header = f"{COMMENT_COLOR}{BOX_TOP_LEFT}{BOX_HORIZONTAL * (box_width + 2)}{RESET_COLOR}\\n"++++            formatted_lines = [f"{COMMENT_COLOR}{BOX_VERTICAL} {line:<{box_width}} {BOX_VERTICAL}{RESET_COLOR}" for line in cleaned_lines]++++            footer = f"{COMMENT_COLOR}{BOX_BOTTOM_LEFT}{BOX_HORIZONTAL * (box_width + 2)}{RESET_COLOR}\\n"++++            ++++            return f"\\n{header}{'\\n'.join(formatted_lines)}\\n{footer}"++++    ++++        # Apply blockquote formatting++++        text = re.sub(r'(^>.*(?:\\n>.*)*)', format_blockquote, text, flags=re.MULTILINE)++++    ++++        # Restore code blocks with yellow coloring (no box)++++        def restore_code_block(match):++++            idx = int(match.group(1))++++            code_content = code_blocks[idx]++++            return f"\\n\\n{BLOCK_CODE_COLOR}{code_content}{RESET_COLOR}\\n\\n"++++            ++++        text = re.sub(r'__CODE_BLOCK_(\\d+)__', restore_code_block, text)++++        ++++        # Final cleanup of excessive newlines++++        text = re.sub(r'\\n{3,}', '\\n\\n', text)++++        ++++        return text.strip()++

@@ -16,6 +16,7 @@ from core.context_analyzer import analyze_context from core.extra_context_fetcher import fetch_extra_context from core.review_engine import run_review from core.review_summarizer import summarize_reviews+from core.utils import format_markdown  def print_header(title: str):     print(f"\n{'='*50}")@@ -175,7 +176,7 @@ def main():         final_summary = summarize_reviews(cl_dir=output_dir, gemini_client=gemini_client, model_name=model_name)          if final_summary:-            print(f"\n{final_summary}\n")+            print(f"\n{format_markdown(final_summary)}\n")          print(f"\n{'+'*50}")         print(f"SUCCESS: Pipeline complete!")

@@ -680,7 +680,7 @@ bool H264Decoder::ModifyReferencePicList(const H264SliceHeader* slice_hdr,              src <= num_ref_idx_lX_active_minus1 + 1; ++src) {           auto* picptr = (*ref_pic_listx)[src].get();           if (!picptr || (LongTermPicNumF(*picptr) !=-                         static_cast<int>(mod.long_term_pic_num))) {+                          static_cast<int>(mod.long_term_pic_num))) {             (*ref_pic_listx)[dst++] = (*ref_pic_listx)[src];           }         }

@@ -1,7 +1,3 @@-// Copyright 2017 The Chromium Authors-// Use of this source code is governed by a BSD-style license that can be-// found in the LICENSE file.- #include "media/gpu/h264_decoder.h"  #include <stdint.h>@@ -497,316 +493,140 @@ TEST_F(H264DecoderTest, SwitchBaselineToHigh) {    ASSERT_TRUE(Mock::VerifyAndClearExpectations(&*accelerator_));   ResetExpectations();--  EXPECT_CALL(*accelerator_, CreateH264Picture()).Times(4);-  EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _)).Times(4);-  EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _)).Times(4);--  Expectation decode_poc0, decode_poc2, decode_poc4, decode_poc6;-  {-    InSequence decode_order;-    decode_poc0 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    decode_poc4 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(4)));-    decode_poc2 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(2)));-    decode_poc6 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(6)));-  }-  {-    InSequence display_order;-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0))).After(decode_poc0);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(2))).After(decode_poc2);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(4))).After(decode_poc4);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(6))).After(decode_poc6);-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());-  ASSERT_TRUE(decoder_->Flush());-}--TEST_F(H264DecoderTest, SwitchHighToBaseline) {-  SetInputFrameFiles({-      kHighFrame0, kBaselineFrame0, kBaselineFrame1, kBaselineFrame2,-      kBaselineFrame3,-  });-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_HIGH, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(16u, decoder_->GetRequiredNumOfPictures());--  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(_));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());--  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&*accelerator_));-  ResetExpectations();--  EXPECT_CALL(*accelerator_, CreateH264Picture()).Times(4);-  EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _)).Times(4);-  EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _)).Times(4);--  Expectation decode_poc0, decode_poc2, decode_poc4, decode_poc6;-  {-    InSequence decode_order;-    decode_poc0 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    decode_poc2 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(2)));-    decode_poc4 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(4)));-    decode_poc6 = EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(6)));-  }-  {-    InSequence display_order;-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0))).After(decode_poc0);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(2))).After(decode_poc2);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(4))).After(decode_poc4);-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(6))).After(decode_poc6);-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());-  ASSERT_TRUE(decoder_->Flush());-}--TEST_F(H264DecoderTest, SwitchYUV420ToNonYUV420) {-  SetInputFrameFiles({kBaselineFrame0, kYUV444Frame});-  // The first frame, YUV420, is decoded with no error.-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());-  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(_));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-  }-  // The second frame, YUV444, causes kDecodeError.-  ASSERT_EQ(AcceleratedVideoDecoder::kDecodeError, Decode());-}--// Verify that the decryption config is passed to the accelerator.-TEST_F(H264DecoderTest, SetEncryptedStream) {-  std::string bitstream;-  auto input_file = GetTestDataFilePath(kBaselineFrame0);-  CHECK(base::ReadFileToString(input_file, &bitstream));--  const char kAnyKeyId[] = "any_16byte_keyid";-  const char kAnyIv[] = "any_16byte_iv___";-  const std::vector<SubsampleEntry> subsamples = {-      // No encrypted bytes. This test only checks whether the data is passed-      // thru to the acclerator so making this completely clear.-      {static_cast<uint32_t>(bitstream.size()), 0},-  };--  std::unique_ptr<DecryptConfig> decrypt_config =-      DecryptConfig::CreateCencConfig(kAnyKeyId, kAnyIv, subsamples);-  EXPECT_CALL(*accelerator_,-              SubmitFrameMetadata(_, _, _, _, _, _,-                                  DecryptConfigMatches(decrypt_config.get())))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kOk));-  EXPECT_CALL(*accelerator_,-              SubmitDecode(DecryptConfigMatches(decrypt_config.get())))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kOk));--  decoder_buffers_.push_back(-      DecoderBuffer::CopyFrom(base::as_byte_span(bitstream)));-  ASSERT_NE(decoder_buffers_.back().get(), nullptr);-  decoder_buffers_.back()->set_decrypt_config(std::move(decrypt_config));-  decoder_->SetStream(0, decoder_buffers_.back());-  EXPECT_EQ(AcceleratedVideoDecoder::kConfigChange, decoder_->Decode());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, decoder_->Decode());-  EXPECT_TRUE(decoder_->Flush());-}--TEST_F(H264DecoderTest, ParseEncryptedSliceHeaderRetry) {-  SetInputFrameFiles({kBaselineFrame0});-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode(true));-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());--  EXPECT_CALL(*accelerator_, ParseEncryptedSliceHeader(_, _, _, _))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode(true));--  // Try again, assuming key still not set. Only ParseEncryptedSliceHeader()-  // should be called again.-  EXPECT_CALL(*accelerator_, ParseEncryptedSliceHeader(_, _, _, _))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode(true));--  // Assume key has been provided now, next call to Decode() should proceed.-  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, ParseEncryptedSliceHeader(_, _, _, _))-        .WillOnce([this](const std::vector<base::span<const uint8_t>>& data,-                         const std::vector<SubsampleEntry>& subsamples,-                         uint64_t /*secure_handle*/,-                         H264SliceHeader* slice_hdr_out) {-          return ParseSliceHeader(-              data, subsamples, accelerator_->last_sps_nalu_data,-              accelerator_->last_pps_nalu_data, slice_hdr_out);-        });-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode(true));--  ASSERT_TRUE(decoder_->Flush()); } -TEST_F(H264DecoderTest, SubmitFrameMetadataRetry) {-  SetInputFrameFiles({kBaselineFrame0});-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());--  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _))-        .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  // Try again, assuming key still not set. Only SubmitFrameMetadata()-  // should be called again.-  EXPECT_CALL(*accelerator_, CreateH264Picture()).Times(0);-  EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  // Assume key has been provided now, next call to Decode() should proceed.-  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());--  ASSERT_TRUE(decoder_->Flush());-}--TEST_F(H264DecoderTest, SubmitSliceRetry) {-  SetInputFrameFiles({kBaselineFrame0});-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());--  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _))-        .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  // Try again, assuming key still not set. Only SubmitSlice() should be-  // called again.-  EXPECT_CALL(*accelerator_, CreateH264Picture()).Times(0);-  EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _)).Times(0);-  EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());+// Custom H264Picture subclass for testing, allowing us to set+// long_term_pic_num.+class TestH264Picture : public H264Picture {+ public:+  TestH264Picture(int long_term_pic_num)+      : long_term_pic_num_(long_term_pic_num) {} -  // Assume key has been provided now, next call to Decode() should proceed.-  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));+  // H264Picture implementation.+  PictureBuffer::TextureUsage Get+      : "Return the texture usage."() const override {+    return PictureBuffer::TextureUsage::DEFAULT;   }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());-  ASSERT_TRUE(decoder_->Flush());-}+  gfx::Size size() const override { return gfx::Size(1, 1); }+  bool AllowOverlay() const override { return false; }+  int long_term_pic_num() const override { return long_term_pic_num_; } -TEST_F(H264DecoderTest, SubmitDecodeRetry) {-  SetInputFrameFiles({kBaselineFrame0, kBaselineFrame1});-  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());+ private:+  ~TestH264Picture() override = default;+  int long_term_pic_num_;+}; -  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(_))-        .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  // Try again, assuming key still not set. Only SubmitDecode() should be-  // called again.-  EXPECT_CALL(*accelerator_, CreateH264Picture()).Times(0);-  EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _)).Times(0);-  EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _)).Times(0);-  EXPECT_CALL(*accelerator_, SubmitDecode(_))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  // Assume key has been provided now, next call to Decode() should output-  // the first frame.-  {-    InSequence sequence;-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(2)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(2)));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());-  ASSERT_TRUE(decoder_->Flush());+TEST_F(H264DecoderTest, ModifyReferencePicList_CompactionWithNullEntry) {+  H264DPB dpb;+  H264Picture::Vector ref_pic_list0;++  // Initial list: {pic1(lt_num=10), null, pic2(lt_num=12)}+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(10));+  ref_pic_list0.push_back(nullptr);+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(12));+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(13));++  H264SliceHeader slice_hdr;+  slice_hdr.num_ref_idx_l0_active_minus1 = 3;  // List size 4++  // Case 2: modification_of_pic_nums_idc = 3+  // Insert pic3(lt_num=11) at ref_idx_l0 = 1.+  // The original bug would fail to compact if the entry at index 1 was null or+  // had the same long_term_pic_num as the inserted picture.+  H264SliceHeader::ReferencePictureListModification mod;+  mod.modification_of_pic_nums_idc = 3;+  mod.long_term_pic_num = 11;++  // Prepare a temporary list for modification, as ModifyReferencePicList+  // modifies in place.+  H264Picture::Vector temp_ref_pic_list0 = ref_pic_list0;++  // Insert a new picture at ref_idx_l0 = 1.+  decoder_->ShiftRightAndInsert(temp_ref_pic_list0, 1,+                                base::MakeRefCounted<TestH264Picture>(11),+                                slice_hdr.num_ref_idx_l0_active_minus1 + 1);++  // Before compaction, the list should be: {pic1(10), pic3(11), null, pic2(12),+  // pic4(13)} The size is num_ref_idx_l0_active_minus1 + 2 = 3+2 = 5+  ASSERT_EQ(temp_ref_pic_list0.size(), 5u);+  ASSERT_EQ(temp_ref_pic_list0[0]->long_term_pic_num(), 10);+  ASSERT_EQ(temp_ref_pic_list0[1]->long_term_pic_num(), 11);+  ASSERT_EQ(temp_ref_pic_list0[2], nullptr);+  ASSERT_EQ(temp_ref_pic_list0[3]->long_term_pic_num(), 12);+  ASSERT_EQ(temp_ref_pic_list0[4]->long_term_pic_num(), 13);++  // Call ModifyReferencePicList.+  // The goal is to compact the list, removing duplicates of long_term_pic_num =+  // 11, and nullptrs. In this scenario, there are no duplicates of 11, but+  // there is a nullptr. The loop should correctly handle the nullptr at+  // index 2. The original bug condition `if (picptr && ...)` would skip the+  // nullptr, leading to incorrect compaction. The corrected `if (!picptr ||+  // ...)` will correctly process it. After modification, the list should+  // compact and remove the nullptr. {pic1(10), pic3(11), pic2(12), pic4(13)} --+  // size 4+  ASSERT_TRUE(decoder_->ModifyReferencePicList(+      &slice_hdr, &dpb, &temp_ref_pic_list0, &temp_ref_pic_list0, 0, &mod));++  // Verify the compacted list.+  ASSERT_EQ(temp_ref_pic_list0.size(), 4u);+  EXPECT_EQ(temp_ref_pic_list0[0]->long_term_pic_num(), 10);+  EXPECT_EQ(temp_ref_pic_list0[1]->long_term_pic_num(), 11);+  EXPECT_EQ(temp_ref_pic_list0[2]->long_term_pic_num(), 12);+  EXPECT_EQ(temp_ref_pic_list0[3]->long_term_pic_num(), 13); } -TEST_F(H264DecoderTest, SetStreamRetry) {-  SetInputFrameFiles({kBaselineFrame0});--  EXPECT_CALL(*accelerator_, SetStream(_, _))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kTryAgain))-      .WillOnce(Return(H264Decoder::H264Accelerator::Status::kOk));-  ASSERT_EQ(AcceleratedVideoDecoder::kTryAgain, Decode());--  ASSERT_EQ(AcceleratedVideoDecoder::kConfigChange, Decode());-  EXPECT_EQ(gfx::Size(320, 192), decoder_->GetPicSize());-  EXPECT_EQ(H264PROFILE_BASELINE, decoder_->GetProfile());-  EXPECT_EQ(8u, decoder_->GetBitDepth());-  EXPECT_LE(9u, decoder_->GetRequiredNumOfPictures());--  {-    InSequence sequence;--    EXPECT_CALL(*accelerator_, CreateH264Picture());-    EXPECT_CALL(*accelerator_, SubmitFrameMetadata(_, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitSlice(_, _, _, _, _, _, _, _));-    EXPECT_CALL(*accelerator_, SubmitDecode(WithPoc(0)));-    EXPECT_CALL(*accelerator_, OutputPicture(WithPoc(0)));-  }-  ASSERT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, Decode());-  ASSERT_TRUE(decoder_->Flush());+TEST_F(H264DecoderTest,+       ModifyReferencePicList_CompactionWithMatchingLongTermPicNum) {+  H264DPB dpb;+  H264Picture::Vector ref_pic_list0;++  // Initial list: {pic1(lt_num=10), pic2(lt_num=11), pic3(lt_num=12)}+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(10));+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(11));+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(12));+  ref_pic_list0.push_back(base::MakeRefCounted<TestH264Picture>(13));++  H264SliceHeader slice_hdr;+  slice_hdr.num_ref_idx_l0_active_minus1 = 3;  // List size 4++  // Case 2: modification_of_pic_nums_idc = 3+  // Insert pic4(lt_num=11) at ref_idx_l0 = 0.+  // This will create a duplicate of long_term_pic_num = 11.+  H264SliceHeader::ReferencePictureListModification mod;+  mod.modification_of_pic_nums_idc = 3;+  mod.long_term_pic_num = 11;++  // Prepare a temporary list for modification.+  H264Picture::Vector temp_ref_pic_list0 = ref_pic_list0;++  // Insert new_pic(lt_num=11) at ref_idx_l0 = 0.+  decoder_->ShiftRightAndInsert(temp_ref_pic_list0, 0,+                                base::MakeRefCounted<TestH264Picture>(11),+                                slice_hdr.num_ref_idx_l0_active_minus1 + 1);++  // Before compaction, the list should be: {new_pic(11), pic1(10), pic2(11),+  // pic3(12), pic4(13)}+  ASSERT_EQ(temp_ref_pic_list0.size(), 5u);+  ASSERT_EQ(temp_ref_pic_list0[0]->long_term_pic_num(), 11);+  ASSERT_EQ(temp_ref_pic_list0[1]->long_term_pic_num(), 10);+  ASSERT_EQ(temp_ref_pic_list0[2]->long_term_pic_num(), 11);  // Duplicate+  ASSERT_EQ(temp_ref_pic_list0[3]->long_term_pic_num(), 12);+  ASSERT_EQ(temp_ref_pic_list0[4]->long_term_pic_num(), 13);++  // Call ModifyReferencePicList.+  // It should compact the list, removing the duplicate long_term_pic_num = 11.+  // The loop should correctly identify and remove the duplicate at index 2.+  // After modification, the list should be: {new_pic(11), pic1(10), pic3(12),+  // pic4(13)}+  ASSERT_TRUE(decoder_->ModifyReferencePicList(+      &slice_hdr, &dpb, &temp_ref_pic_list0, &temp_ref_pic_list0, 0, &mod));++  // Verify the compacted list.+  ASSERT_EQ(temp_ref_pic_list0.size(), 4u);+  EXPECT_EQ(temp_ref_pic_list0[0]->long_term_pic_num(), 11);+  EXPECT_EQ(temp_ref_pic_list0[1]->long_term_pic_num(), 10);+  EXPECT_EQ(temp_ref_pic_list0[2]->long_term_pic_num(), 12);+  EXPECT_EQ(temp_ref_pic_list0[3]->long_term_pic_num(), 13); }  }  // namespace

@@ -10,11 +10,29 @@ #include "components/browser_ui/photo_picker/android/photo_picker_jni_headers/PhotoPickerFeatures_jni.h"  namespace photo_picker {+ namespace features { ++ BASE_FEATURE(kAndroidMediaPickerRegression,++               +"MediaPickerRegression",++               +base::FEATURE_DISABLED_BY_DEFAULT);+++ +    + static int64_t+      JNI_PhotoPickerFeatures_GetAndroidMediaPickerRegressionFeature(+          JNIEnv* env) {+  +return reinterpret_cast<int64_t>(&kAndroidMediaPickerRegression);++  ++}+++  }  // namespace features+ }  // namespace photo_picker  DEFINE_JNI(PhotoPickerFeatures)