diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index aac5b7a..511b9d8 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -25,6 +25,7 @@
 #include "base/files/file_path.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback.h"
+#include "base/functional/callback_helpers.h"
 #include "base/i18n/base_i18n_switches.h"
 #include "base/i18n/character_encoding.h"
 #include "base/memory/raw_ptr.h"
@@ -115,6 +116,8 @@
 #include "chrome/browser/performance_manager/public/chrome_browser_main_extra_parts_performance_manager.h"
 #include "chrome/browser/performance_manager/public/chrome_content_browser_client_performance_manager_part.h"
 #include "chrome/browser/performance_monitor/chrome_browser_main_extra_parts_performance_monitor.h"
+#include "chrome/browser/picture_in_picture/picture_in_picture_window_manager.h"
+#include "chrome/browser/picture_in_picture/scoped_tuck_picture_in_picture.h"
 #include "chrome/browser/plugins/plugin_utils.h"
 #include "chrome/browser/policy/policy_util.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
@@ -6943,6 +6946,22 @@
   return content::VideoOverlayWindow::Create(controller);
 }
 
+base::ScopedClosureRunner
+ChromeContentBrowserClient::MaybeGetScopedPictureInPictureTucker(
+    content::WebContents* web_contents) {
+#if !BUILDFLAG(IS_ANDROID)
+  if (PictureInPictureWindowManager::GetInstance()
+          ->ShouldFileDialogTuckPictureInPicture(web_contents)) {
+    // Make the `ScopedTuckPictureInPicture` share the same lifecycle as the
+    // `ScopedClosureRunner`.
+    auto tucker = std::make_unique<ScopedTuckPictureInPicture>();
+    return base::ScopedClosureRunner(
+        base::DoNothingWithBoundArgs(std::move(tucker)));
+  }
+#endif
+  return base::ScopedClosureRunner();
+}
+
 media::PictureInPictureEventsInfo::AutoPipInfo
 ChromeContentBrowserClient::GetAutoPipInfo(
     const content::WebContents& web_contents) const {
diff --git a/chrome/browser/chrome_content_browser_client.h b/chrome/browser/chrome_content_browser_client.h
index 63c5ae80..ac5795f 100644
--- a/chrome/browser/chrome_content_browser_client.h
+++ b/chrome/browser/chrome_content_browser_client.h
@@ -829,6 +829,8 @@
   std::unique_ptr<content::VideoOverlayWindow>
   CreateWindowForVideoPictureInPicture(
       content::VideoPictureInPictureWindowController* controller) override;
+  base::ScopedClosureRunner MaybeGetScopedPictureInPictureTucker(
+      content::WebContents* web_contents) override;
   media::PictureInPictureEventsInfo::AutoPipInfo GetAutoPipInfo(
       const content::WebContents& web_contents) const override;
   void RegisterRendererPreferenceWatcher(
diff --git a/content/browser/file_system_access/file_system_access_manager_impl.cc b/content/browser/file_system_access/file_system_access_manager_impl.cc
index a87c6b9..8debb42 100644
--- a/content/browser/file_system_access/file_system_access_manager_impl.cc
+++ b/content/browser/file_system_access/file_system_access_manager_impl.cc
@@ -226,10 +226,16 @@
     return;
   }
 #endif
+
   FileSystemChooser::ScopedObjects scoped_objects(
       // Drop fullscreen mode so that the user sees the URL bar.
       /*fullscreen_block=*/web_contents->ForSecurityDropFullscreen(
-          display::kInvalidDisplayId));
+          display::kInvalidDisplayId),
+      // Maybe tuck the pip window so that it would not block the file picker
+      // UI.
+      /*pip_tucker=*/GetContentClient()
+          ->browser()
+          ->MaybeGetScopedPictureInPictureTucker(web_contents));
 
   FileSystemChooser::CreateAndShow(web_contents, options, std::move(callback),
                                    std::move(scoped_objects));
diff --git a/content/browser/file_system_access/file_system_chooser.cc b/content/browser/file_system_access/file_system_chooser.cc
index f0ba97c2..50ca62bc 100644
--- a/content/browser/file_system_access/file_system_chooser.cc
+++ b/content/browser/file_system_access/file_system_chooser.cc
@@ -9,6 +9,7 @@
 
 #include "base/check.h"
 #include "base/files/file_path.h"
+#include "base/functional/callback_helpers.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/rtl.h"
 #include "base/strings/string_util.h"
@@ -287,8 +288,10 @@
     ScopedObjects&&) = default;
 
 FileSystemChooser::ScopedObjects::ScopedObjects(
-    base::ScopedClosureRunner&& fullscreen_block)
-    : fullscreen_block(std::move(fullscreen_block)) {}
+    base::ScopedClosureRunner&& fullscreen_block,
+    base::ScopedClosureRunner&& pip_tucker)
+    : fullscreen_block(std::move(fullscreen_block)),
+      pip_tucker(std::move(pip_tucker)) {}
 
 // static
 void FileSystemChooser::CreateAndShow(
diff --git a/content/browser/file_system_access/file_system_chooser.h b/content/browser/file_system_access/file_system_chooser.h
index f05aa355..440e0d0f 100644
--- a/content/browser/file_system_access/file_system_chooser.h
+++ b/content/browser/file_system_access/file_system_chooser.h
@@ -83,9 +83,11 @@
     ScopedObjects& operator=(ScopedObjects&&);
     ScopedObjects(const ScopedObjects&) = delete;
     ScopedObjects& operator=(const ScopedObjects&) = delete;
-    explicit ScopedObjects(base::ScopedClosureRunner&& fullscreen_block);
+    ScopedObjects(base::ScopedClosureRunner&& fullscreen_block,
+                  base::ScopedClosureRunner&& pip_tucker);
 
     base::ScopedClosureRunner fullscreen_block;
+    base::ScopedClosureRunner pip_tucker;
   };
 
   static void CreateAndShow(WebContents* web_contents,
diff --git a/content/public/browser/content_browser_client.cc b/content/public/browser/content_browser_client.cc
index a1968cc5..51635fb9 100644
--- a/content/public/browser/content_browser_client.cc
+++ b/content/public/browser/content_browser_client.cc
@@ -1358,6 +1358,12 @@
   return nullptr;
 }
 
+base::ScopedClosureRunner
+ContentBrowserClient::MaybeGetScopedPictureInPictureTucker(
+    WebContents* web_contents) {
+  return base::ScopedClosureRunner();
+}
+
 media::PictureInPictureEventsInfo::AutoPipInfo
 ContentBrowserClient::GetAutoPipInfo(const WebContents& web_contents) const {
   return media::PictureInPictureEventsInfo::AutoPipInfo();
diff --git a/content/public/browser/content_browser_client.h b/content/public/browser/content_browser_client.h
index b73ee6e7..f9131c7b 100644
--- a/content/public/browser/content_browser_client.h
+++ b/content/public/browser/content_browser_client.h
@@ -125,6 +125,7 @@
 class FilePath;
 class Location;
 class SequencedTaskRunner;
+class ScopedClosureRunner;
 }  // namespace base
 
 namespace blink {
@@ -2519,6 +2520,11 @@
   CreateWindowForVideoPictureInPicture(
       VideoPictureInPictureWindowController* controller);
 
+  // Creates a scoper that will tuck picture-in-picture windows for the lifetime
+  // of the scoper.
+  virtual base::ScopedClosureRunner MaybeGetScopedPictureInPictureTucker(
+      WebContents* web_contents);
+
   // Returns information related to auto picture in picture. The auto picture in
   // picture reason is recorded in metrics.
   virtual media::PictureInPictureEventsInfo::AutoPipInfo GetAutoPipInfo(
diff --git a/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc b/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
index 3958a4c..eb90a111 100644
--- a/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
+++ b/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
@@ -49,6 +49,7 @@
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/fenced_frame_test_util.h"
+#include "content/public/test/file_system_chooser_test_helpers.h"
 #include "content/public/test/media_start_stop_observer.h"
 #include "content/public/test/prerender_test_util.h"
 #include "content/public/test/test_navigation_observer.h"
@@ -70,6 +71,8 @@
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/shell_dialogs/select_file_dialog.h"
+#include "ui/shell_dialogs/select_file_dialog_factory.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/test/button_test_api.h"
 #include "ui/views/view_observer.h"
@@ -980,3 +983,106 @@
             browser_view->GetAccessibleTabLabel(
                 browser()->tab_strip_model()->active_index()));
 }
+
+// A dialog that checks if the picture-in-picture window is force-tucked
+// when the dialog is shown, and then immediately cancels itself.
+class TuckingTestSelectFileDialog : public ui::SelectFileDialog {
+ public:
+  TuckingTestSelectFileDialog(Listener* listener,
+                              std::unique_ptr<ui::SelectFilePolicy> policy,
+                              bool* was_tucked)
+      : ui::SelectFileDialog(listener, std::move(policy)),
+        was_tucked_(was_tucked) {}
+
+ private:
+  ~TuckingTestSelectFileDialog() override = default;
+
+  // ui::SelectFileDialog overrides
+  void SelectFileImpl(Type type,
+                      const std::u16string& title,
+                      const base::FilePath& default_path,
+                      const FileTypeInfo* file_types,
+                      int file_type_index,
+                      const base::FilePath::StringType& default_extension,
+                      gfx::NativeWindow owning_window,
+                      const GURL* caller) override {
+    *was_tucked_ = PictureInPictureWindowManager::GetInstance()
+                       ->IsPictureInPictureForceTucked();
+    listener_->FileSelectionCanceled();
+  }
+
+  bool IsRunning(gfx::NativeWindow owning_window) const override {
+    return true;
+  }
+  void ListenerDestroyed() override {}
+  bool HasMultipleFileTypeChoicesImpl() override { return false; }
+
+  raw_ptr<bool> was_tucked_;
+  base::WeakPtrFactory<TuckingTestSelectFileDialog> weak_factory_{this};
+};
+
+class TuckingTestSelectFileDialogFactory : public ui::SelectFileDialogFactory {
+ public:
+  explicit TuckingTestSelectFileDialogFactory(bool* was_tucked)
+      : was_tucked_(was_tucked) {}
+  ~TuckingTestSelectFileDialogFactory() override = default;
+
+  ui::SelectFileDialog* Create(
+      ui::SelectFileDialog::Listener* listener,
+      std::unique_ptr<ui::SelectFilePolicy> policy) override {
+    return new TuckingTestSelectFileDialog(listener, std::move(policy),
+                                           was_tucked_);
+  }
+
+ private:
+  raw_ptr<bool> was_tucked_;
+};
+
+class DocumentPictureInPictureWindowControllerTuckingBrowserTest
+    : public DocumentPictureInPictureWindowControllerBrowserTest {
+ public:
+  DocumentPictureInPictureWindowControllerTuckingBrowserTest() = default;
+
+  void SetUp() override {
+    feature_list_.InitWithFeatures(
+        {blink::features::kDocumentPictureInPictureAPI,
+         blink::features::kDocumentPictureInPicturePreferInitialPlacement,
+         media::kFileDialogsTuckPictureInPicture},
+        {});
+    InProcessBrowserTest::SetUp();
+  }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+};
+
+// Test when the file picker is opened, the pip window is tucked.
+IN_PROC_BROWSER_TEST_F(
+    DocumentPictureInPictureWindowControllerTuckingBrowserTest,
+    TuckOnOpenFilePicker) {
+  LoadTabAndEnterPictureInPicture(browser());
+  // Initially it was not tucked
+  EXPECT_FALSE(PictureInPictureWindowManager::GetInstance()
+                   ->IsPictureInPictureForceTucked());
+
+  // `was_tucked_during_picker` will be updated if the window is tucked while
+  // the file picker dialog is open.
+  bool was_tucked_during_picker = false;
+  ui::SelectFileDialog::SetFactory(
+      std::make_unique<TuckingTestSelectFileDialogFactory>(
+          &was_tucked_during_picker));
+
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  auto result = EvalJs(web_contents, "window.showOpenFilePicker();");
+  EXPECT_TRUE(result.ExtractError().find("aborted") != std::string::npos)
+      << result;
+
+  ui::SelectFileDialog::SetFactory(nullptr);
+
+  // The pip window should be tucked once, and now it's back to non-tucked
+  // state.
+  EXPECT_TRUE(was_tucked_during_picker);
+  EXPECT_FALSE(PictureInPictureWindowManager::GetInstance()
+                   ->IsPictureInPictureForceTucked());
+}

diff --git a/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc b/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
index 3958a4c..eb90a111 100644
--- a/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
+++ b/chrome/browser/picture_in_picture/document_picture_in_picture_window_controller_browsertest.cc
@@ -49,6 +49,7 @@
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/fenced_frame_test_util.h"
+#include "content/public/test/file_system_chooser_test_helpers.h"
 #include "content/public/test/media_start_stop_observer.h"
 #include "content/public/test/prerender_test_util.h"
 #include "content/public/test/test_navigation_observer.h"
@@ -70,6 +71,8 @@
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/shell_dialogs/select_file_dialog.h"
+#include "ui/shell_dialogs/select_file_dialog_factory.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/test/button_test_api.h"
 #include "ui/views/view_observer.h"
@@ -980,3 +983,106 @@
             browser_view->GetAccessibleTabLabel(
                 browser()->tab_strip_model()->active_index()));
 }
+
+// A dialog that checks if the picture-in-picture window is force-tucked
+// when the dialog is shown, and then immediately cancels itself.
+class TuckingTestSelectFileDialog : public ui::SelectFileDialog {
+ public:
+  TuckingTestSelectFileDialog(Listener* listener,
+                              std::unique_ptr<ui::SelectFilePolicy> policy,
+                              bool* was_tucked)
+      : ui::SelectFileDialog(listener, std::move(policy)),
+        was_tucked_(was_tucked) {}
+
+ private:
+  ~TuckingTestSelectFileDialog() override = default;
+
+  // ui::SelectFileDialog overrides
+  void SelectFileImpl(Type type,
+                      const std::u16string& title,
+                      const base::FilePath& default_path,
+                      const FileTypeInfo* file_types,
+                      int file_type_index,
+                      const base::FilePath::StringType& default_extension,
+                      gfx::NativeWindow owning_window,
+                      const GURL* caller) override {
+    *was_tucked_ = PictureInPictureWindowManager::GetInstance()
+                       ->IsPictureInPictureForceTucked();
+    listener_->FileSelectionCanceled();
+  }
+
+  bool IsRunning(gfx::NativeWindow owning_window) const override {
+    return true;
+  }
+  void ListenerDestroyed() override {}
+  bool HasMultipleFileTypeChoicesImpl() override { return false; }
+
+  raw_ptr<bool> was_tucked_;
+  base::WeakPtrFactory<TuckingTestSelectFileDialog> weak_factory_{this};
+};
+
+class TuckingTestSelectFileDialogFactory : public ui::SelectFileDialogFactory {
+ public:
+  explicit TuckingTestSelectFileDialogFactory(bool* was_tucked)
+      : was_tucked_(was_tucked) {}
+  ~TuckingTestSelectFileDialogFactory() override = default;
+
+  ui::SelectFileDialog* Create(
+      ui::SelectFileDialog::Listener* listener,
+      std::unique_ptr<ui::SelectFilePolicy> policy) override {
+    return new TuckingTestSelectFileDialog(listener, std::move(policy),
+                                           was_tucked_);
+  }
+
+ private:
+  raw_ptr<bool> was_tucked_;
+};
+
+class DocumentPictureInPictureWindowControllerTuckingBrowserTest
+    : public DocumentPictureInPictureWindowControllerBrowserTest {
+ public:
+  DocumentPictureInPictureWindowControllerTuckingBrowserTest() = default;
+
+  void SetUp() override {
+    feature_list_.InitWithFeatures(
+        {blink::features::kDocumentPictureInPictureAPI,
+         blink::features::kDocumentPictureInPicturePreferInitialPlacement,
+         media::kFileDialogsTuckPictureInPicture},
+        {});
+    InProcessBrowserTest::SetUp();
+  }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+};
+
+// Test when the file picker is opened, the pip window is tucked.
+IN_PROC_BROWSER_TEST_F(
+    DocumentPictureInPictureWindowControllerTuckingBrowserTest,
+    TuckOnOpenFilePicker) {
+  LoadTabAndEnterPictureInPicture(browser());
+  // Initially it was not tucked
+  EXPECT_FALSE(PictureInPictureWindowManager::GetInstance()
+                   ->IsPictureInPictureForceTucked());
+
+  // `was_tucked_during_picker` will be updated if the window is tucked while
+  // the file picker dialog is open.
+  bool was_tucked_during_picker = false;
+  ui::SelectFileDialog::SetFactory(
+      std::make_unique<TuckingTestSelectFileDialogFactory>(
+          &was_tucked_during_picker));
+
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  auto result = EvalJs(web_contents, "window.showOpenFilePicker();");
+  EXPECT_TRUE(result.ExtractError().find("aborted") != std::string::npos)
+      << result;
+
+  ui::SelectFileDialog::SetFactory(nullptr);
+
+  // The pip window should be tucked once, and now it's back to non-tucked
+  // state.
+  EXPECT_TRUE(was_tucked_during_picker);
+  EXPECT_FALSE(PictureInPictureWindowManager::GetInstance()
+                   ->IsPictureInPictureForceTucked());
+}