Change WebContentsDelegate::RunFileChooser to be frame based.

chrome/browser/file_select_helper.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/file_select_helper.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 12 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/file_chooser_file_info.h"
 #include "content/public/common/file_chooser_params.h"
 #include "net/base/filename_util.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 80 matching lines @@
   ActiveDirectoryEnumeration() : rvh_(NULL) {}
 
   std::unique_ptr<DirectoryListerDispatchDelegate> delegate_;
   std::unique_ptr<net::DirectoryLister> lister_;
   RenderViewHost* rvh_;
   std::vector<base::FilePath> results_;
 };
 
 FileSelectHelper::FileSelectHelper(Profile* profile)
     : profile_(profile),
-      render_view_host_(NULL),
-      web_contents_(NULL),
+      render_frame_host_(nullptr),
+      web_contents_(nullptr),
       select_file_dialog_(),
       select_file_types_(),
       dialog_type_(ui::SelectFileDialog::SELECT_OPEN_FILE),
-      dialog_mode_(FileChooserParams::Open) {
-}
+      dialog_mode_(FileChooserParams::Open) {}
 
 FileSelectHelper::~FileSelectHelper() {
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 
   // Stop any pending directory enumeration, prevent a callback, and free
   // allocated memory.
   std::map<int, ActiveDirectoryEnumeration*>::iterator iter;
@@ skipping 19 matching lines @@
   FileSelectedWithExtraInfo(ui::SelectedFileInfo(path, path), index, params);
 }
 
 void FileSelectHelper::FileSelectedWithExtraInfo(
     const ui::SelectedFileInfo& file,
     int index,
     void* params) {
   if (IsValidProfile(profile_))
     profile_->set_last_selected_directory(file.file_path.DirName());
 
-  if (!render_view_host_) {
+  if (!render_frame_host_) {
     RunFileChooserEnd();
     return;
   }
 
   const base::FilePath& path = file.local_path;
   if (dialog_type_ == ui::SelectFileDialog::SELECT_UPLOAD_FOLDER) {
-    StartNewEnumeration(path, kFileSelectEnumerationId, render_view_host_);
+    StartNewEnumeration(path, kFileSelectEnumerationId,
+                        render_frame_host_->GetRenderViewHost());
     return;
   }
 
   std::vector<ui::SelectedFileInfo> files;
   files.push_back(file);
 
 #if defined(OS_MACOSX)
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE_USER_BLOCKING,
       FROM_HERE,
@@ skipping 82 matching lines @@
   if (id == kFileSelectEnumerationId) {
     NotifyRenderViewHostAndEnd(selected_files);
   } else {
     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
     EnumerateDirectoryEnd();
   }
 }
 
 void FileSelectHelper::NotifyRenderViewHostAndEnd(
     const std::vector<ui::SelectedFileInfo>& files) {
-  if (!render_view_host_) {
+  if (!render_frame_host_) {
     RunFileChooserEnd();
     return;
   }
 
 #if defined(OS_CHROMEOS)
   if (!files.empty()) {
     if (!IsValidProfile(profile_)) {
       RunFileChooserEnd();
       return;
     }
     // Converts |files| into FileChooserFileInfo with handling of non-native
     // files.
+    content::SiteInstance* site_instance =
+        render_frame_host_->GetSiteInstance();
     storage::FileSystemContext* file_system_context =
-        content::BrowserContext::GetStoragePartition(
-            profile_, render_view_host_->GetSiteInstance())->
-                GetFileSystemContext();
+        content::BrowserContext::GetStoragePartition(profile_, site_instance)
+            ->GetFileSystemContext();
     file_manager::util::ConvertSelectedFileInfoListToFileChooserFileInfoList(
-        file_system_context,
-        web_contents_->GetSiteInstance()->GetSiteURL(),
-        files,
-        base::Bind(
-            &FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion,
-            this));
+        file_system_context, site_instance->GetSiteURL(), files,
+        base::Bind(&FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion,
+                   this));
     return;
   }
 #endif  // defined(OS_CHROMEOS)
 
   std::vector<content::FileChooserFileInfo> chooser_files;
   for (const auto& file : files) {
     content::FileChooserFileInfo chooser_file;
     chooser_file.file_path = file.local_path;
     chooser_file.display_name = file.display_name;
     chooser_files.push_back(chooser_file);
   }
 
   NotifyRenderViewHostAndEndAfterConversion(chooser_files);
 }
 
 void FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion(
     const std::vector<content::FileChooserFileInfo>& list) {
-  if (render_view_host_)
-    render_view_host_->FilesSelectedInChooser(list, dialog_mode_);
+  if (render_frame_host_)
+    render_frame_host_->FilesSelectedInChooser(list, dialog_mode_);
 
   // No members should be accessed from here on.
   RunFileChooserEnd();
 }
 
 void FileSelectHelper::DeleteTemporaryFiles() {
   BrowserThread::PostTask(BrowserThread::FILE,
                           FROM_HERE,
                           base::Bind(&DeleteFiles, temporary_files_));
   temporary_files_.clear();
@@ skipping 71 matching lines @@
 
   if (description_id) {
     file_type->extension_description_overrides.push_back(
         l10n_util::GetStringUTF16(description_id));
   }
 
   return file_type;
 }
 
 // static
-void FileSelectHelper::RunFileChooser(content::WebContents* tab,
-                                      const FileChooserParams& params) {
-  Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
+void FileSelectHelper::RunFileChooser(
+    content::RenderFrameHost* render_frame_host,
+    const FileChooserParams& params) {
+  Profile* profile = Profile::FromBrowserContext(
+      render_frame_host->GetProcess()->GetBrowserContext());
   // FileSelectHelper will keep itself alive until it sends the result message.
   scoped_refptr<FileSelectHelper> file_select_helper(
       new FileSelectHelper(profile));
   file_select_helper->RunFileChooser(
-      tab->GetRenderViewHost(), tab,
+      render_frame_host,
       base::WrapUnique(new content::FileChooserParams(params)));
 }
 
 // static
 void FileSelectHelper::EnumerateDirectory(content::WebContents* tab,
                                           int request_id,
                                           const base::FilePath& path) {
   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
   // FileSelectHelper will keep itself alive until it sends the result message.
   scoped_refptr<FileSelectHelper> file_select_helper(
       new FileSelectHelper(profile));
   file_select_helper->EnumerateDirectory(
       request_id, tab->GetRenderViewHost(), path);
 }
 
 void FileSelectHelper::RunFileChooser(
-    RenderViewHost* render_view_host,
-    content::WebContents* web_contents,
+    content::RenderFrameHost* render_frame_host,
     std::unique_ptr<FileChooserParams> params) {
-  DCHECK(!render_view_host_);
+  DCHECK(!render_frame_host_);
   DCHECK(!web_contents_);
   DCHECK(params->default_file_name.empty() ||
          params->mode == FileChooserParams::Save)
       << "The default_file_name parameter should only be specified for Save "
          "file choosers";
   DCHECK(params->default_file_name == params->default_file_name.BaseName())
       << "The default_file_name parameter should not contain path separators";
 
-  render_view_host_ = render_view_host;
-  web_contents_ = web_contents;
+  render_frame_host_ = render_frame_host;
+  web_contents_ = WebContents::FromRenderFrameHost(render_frame_host);
   notification_registrar_.RemoveAll();
   content::WebContentsObserver::Observe(web_contents_);
   notification_registrar_.Add(
       this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-      content::Source<RenderWidgetHost>(render_view_host_->GetWidget()));
+      content::Source<RenderWidgetHost>(
+          render_frame_host_->GetRenderViewHost()->GetWidget()));
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&FileSelectHelper::GetFileTypesOnFileThread, this,
                  base::Passed(&params)));
 
   // Because this class returns notifications to the RenderViewHost, it is
   // difficult for callers to know how long to keep a reference to this
   // instance. We AddRef() here to keep the instance alive after we return
   // to the caller, until the last callback is received from the file dialog.
@@ skipping 67 matching lines @@
     return;
   }
   RunFileChooserOnUIThread(default_file_path, std::move(params));
 }
 #endif
 
 void FileSelectHelper::RunFileChooserOnUIThread(
     const base::FilePath& default_file_path,
     std::unique_ptr<FileChooserParams> params) {
   DCHECK(params);
-  if (!render_view_host_ || !web_contents_ || !IsValidProfile(profile_) ||
-      !render_view_host_->GetWidget()->GetView()) {
+  if (!render_frame_host_ || !web_contents_ || !IsValidProfile(profile_) ||
+      !web_contents_->GetNativeView()) {
     // If the renderer was destroyed before we started, just cancel the
     // operation.
     RunFileChooserEnd();
     return;
   }
 
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_contents_));
   if (!select_file_dialog_.get())
     return;
@@ skipping 11 matching lines @@
       break;
     case FileChooserParams::Save:
       dialog_type_ = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
       break;
     default:
       // Prevent warning.
       dialog_type_ = ui::SelectFileDialog::SELECT_OPEN_FILE;
       NOTREACHED();
   }
 
-  gfx::NativeWindow owning_window = platform_util::GetTopLevel(
-      render_view_host_->GetWidget()->GetView()->GetNativeView());
+  gfx::NativeWindow owning_window =
+      platform_util::GetTopLevel(web_contents_->GetNativeView());
 
 #if defined(OS_ANDROID)
   // Android needs the original MIME types and an additional capture value.
   std::pair<std::vector<base::string16>, bool> accept_types =
       std::make_pair(params->accept_types, params->capture);
 #endif
 
   select_file_dialog_->SelectFile(
       dialog_type_, params->title, default_file_path, select_file_types_.get(),
       select_file_types_.get() && !select_file_types_->extensions.empty()
@@ skipping 13 matching lines @@
 // This method is called when we receive the last callback from the file
 // chooser dialog. Perform any cleanup and release the reference we added
 // in RunFileChooser().
 void FileSelectHelper::RunFileChooserEnd() {
   // If there are temporary files, then this instance needs to stick around
   // until web_contents_ is destroyed, so that this instance can delete the
   // temporary files.
   if (!temporary_files_.empty())
     return;
 
-  render_view_host_ = NULL;
-  web_contents_ = NULL;
+  render_frame_host_ = nullptr;
+  web_contents_ = nullptr;
   Release();
 }
 
 void FileSelectHelper::EnumerateDirectory(int request_id,
                                           RenderViewHost* render_view_host,
                                           const base::FilePath& path) {
 
   // Because this class returns notifications to the RenderViewHost, it is
   // difficult for callers to know how long to keep a reference to this
   // instance. We AddRef() here to keep the instance alive after we return
   // to the caller, until the last callback is received from the enumeration
   // code. At that point, we must call EnumerateDirectoryEnd().
   AddRef();
   StartNewEnumeration(path, request_id, render_view_host);
 }
 
 // This method is called when we receive the last callback from the enumeration
 // code. Perform any cleanup and release the reference we added in
 // EnumerateDirectory().
 void FileSelectHelper::EnumerateDirectoryEnd() {
   Release();
 }
 
 void FileSelectHelper::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
       DCHECK(content::Source<RenderWidgetHost>(source).ptr() ==
-             render_view_host_->GetWidget());
-      render_view_host_ = NULL;
+             render_frame_host_->GetRenderViewHost()->GetWidget());
+      render_frame_host_ = NULL;
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void FileSelectHelper::RenderViewHostChanged(RenderViewHost* old_host,
                                              RenderViewHost* new_host) {
   CleanUpOnRenderViewHostChange();
@@ skipping 21 matching lines @@
 
 // static
 base::FilePath FileSelectHelper::GetSanitizedFileName(
     const base::FilePath& suggested_filename) {
   if (suggested_filename.empty())
     return base::FilePath();
   return net::GenerateFileName(
       GURL(), std::string(), std::string(), suggested_filename.AsUTF8Unsafe(),
       std::string(), l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
 }