Update FileSelectHelper to use RenderFrameHost notifications.

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 180 matching lines @@
 
   std::vector<ui::SelectedFileInfo> files;
   files.push_back(file);
 
 #if defined(OS_MACOSX)
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE_USER_BLOCKING,
       FROM_HERE,
       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
 #else
-  NotifyRenderViewHostAndEnd(files);
+  NotifyRenderFrameHostAndEnd(files);
 #endif  // defined(OS_MACOSX)
 }
 
 void FileSelectHelper::MultiFilesSelected(
     const std::vector<base::FilePath>& files,
     void* params) {
   std::vector<ui::SelectedFileInfo> selected_files =
       FilePathListToSelectedFileInfoList(files);
 
   MultiFilesSelectedWithExtraInfo(selected_files, params);
 }
 
 void FileSelectHelper::MultiFilesSelectedWithExtraInfo(
     const std::vector<ui::SelectedFileInfo>& files,
     void* params) {
   if (!files.empty() && IsValidProfile(profile_))
     profile_->set_last_selected_directory(files[0].file_path.DirName());
 
 #if defined(OS_MACOSX)
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE_USER_BLOCKING,
       FROM_HERE,
       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
 #else
-  NotifyRenderViewHostAndEnd(files);
+  NotifyRenderFrameHostAndEnd(files);
 #endif  // defined(OS_MACOSX)
 }
 
 void FileSelectHelper::FileSelectionCanceled(void* params) {
-  NotifyRenderViewHostAndEnd(std::vector<ui::SelectedFileInfo>());
+  NotifyRenderFrameHostAndEnd(std::vector<ui::SelectedFileInfo>());
 }
 
 void FileSelectHelper::StartNewEnumeration(const base::FilePath& path,
                                            int request_id,
                                            RenderViewHost* render_view_host) {
   std::unique_ptr<ActiveDirectoryEnumeration> entry(
       new ActiveDirectoryEnumeration);
   entry->rvh_ = render_view_host;
   entry->delegate_.reset(new DirectoryListerDispatchDelegate(this, request_id));
   entry->lister_.reset(new net::DirectoryLister(
@@ skipping 30 matching lines @@
     return;
   if (error) {
     FileSelectionCanceled(NULL);
     return;
   }
 
   std::vector<ui::SelectedFileInfo> selected_files =
       FilePathListToSelectedFileInfoList(entry->results_);
 
   if (id == kFileSelectEnumerationId) {
-    NotifyRenderViewHostAndEnd(selected_files);
+    NotifyRenderFrameHostAndEnd(selected_files);
   } else {
     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
     EnumerateDirectoryEnd();
   }
 }
 
-void FileSelectHelper::NotifyRenderViewHostAndEnd(
+void FileSelectHelper::NotifyRenderFrameHostAndEnd(
     const std::vector<ui::SelectedFileInfo>& files) {
   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_, site_instance)
             ->GetFileSystemContext();
     file_manager::util::ConvertSelectedFileInfoListToFileChooserFileInfoList(
         file_system_context, site_instance->GetSiteURL(), files,
-        base::Bind(&FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion,
-                   this));
+        base::Bind(
+            &FileSelectHelper::NotifyRenderFrameHostAndEndAfterConversion,
+            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);
+  NotifyRenderFrameHostAndEndAfterConversion(chooser_files);
 }
 
-void FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion(
+void FileSelectHelper::NotifyRenderFrameHostAndEndAfterConversion(
     const std::vector<content::FileChooserFileInfo>& list) {
   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();
 }
 
-void FileSelectHelper::CleanUpOnRenderViewHostChange() {
+void FileSelectHelper::CleanUp() {
   if (!temporary_files_.empty()) {
     DeleteTemporaryFiles();
 
     // Now that the temporary files have been scheduled for deletion, there
     // is no longer any reason to keep this instance around.
     Release();
   }
 }
 
 std::unique_ptr<ui::SelectFileDialog::FileTypeInfo>
@@ skipping 179 matching lines @@
       base::Bind(&InterpretSafeBrowsingVerdict,
                  base::Bind(&FileSelectHelper::ProceedWithSafeBrowsingVerdict,
                             this, default_file_path, base::Passed(&params))));
 }
 
 void FileSelectHelper::ProceedWithSafeBrowsingVerdict(
     const base::FilePath& default_file_path,
     std::unique_ptr<content::FileChooserParams> params,
     bool allowed_by_safe_browsing) {
   if (!allowed_by_safe_browsing) {
-    NotifyRenderViewHostAndEnd(std::vector<ui::SelectedFileInfo>());
+    NotifyRenderFrameHostAndEnd(std::vector<ui::SelectedFileInfo>());
     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);
@@ skipping 86 matching lines @@
 // 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) {
   DCHECK_EQ(content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED, type);
-  DCHECK_EQ(content::Source<RenderWidgetHost>(source).ptr(),
-            render_frame_host_->GetRenderViewHost()->GetWidget());
   render_frame_host_ = nullptr;
 }
 
-void FileSelectHelper::RenderViewHostChanged(RenderViewHost* old_host,
-                                             RenderViewHost* new_host) {
-  CleanUpOnRenderViewHostChange();
+void FileSelectHelper::RenderFrameHostChanged(
+    content::RenderFrameHost* old_host,
+    content::RenderFrameHost* new_host) {
+  render_frame_host_ = nullptr;
+}
+
+void FileSelectHelper::RenderFrameDeleted(
+    content::RenderFrameHost* render_frame_host) {
+  render_frame_host_ = nullptr;
 }
 
 void FileSelectHelper::WebContentsDestroyed() {
+  render_frame_host_ = nullptr;
   web_contents_ = nullptr;
-  CleanUpOnRenderViewHostChange();
+  CleanUp();
 }
 
 // static
 bool FileSelectHelper::IsAcceptTypeValid(const std::string& accept_type) {
   // TODO(raymes): This only does some basic checks, extend to test more cases.
   // A 1 character accept type will always be invalid (either a "." in the case
   // of an extension or a "/" in the case of a MIME type).
   std::string unused;
   if (accept_type.length() <= 1 ||
       base::ToLowerASCII(accept_type) != accept_type ||
       base::TrimWhitespaceASCII(accept_type, base::TRIM_ALL, &unused) !=
           base::TRIM_NONE) {
     return false;
   }
   return true;
 }
 
 // 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));
 }