Fix a crash in the FileSystem API when the app window closes during a call.

chrome/browser/extensions/api/file_system/file_system_api.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/extensions/api/file_system/file_system_api.h"
 
 #include "apps/saved_files_service.h"
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "base/bind.h"
@@ skipping 146 matching lines @@
   std::string filesystem_id;
   if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
     *error = kInvalidParameters;
     return false;
   }
 
   // Only return the display path if the process has read access to the
   // filesystem.
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
+  DCHECK(render_view_host);

[benwells, 2013/09/10 00:47:14]

Why add all these DCHECKs?

[Sam McNally, 2013/09/10 01:04:13]

No real reason.

   if (!policy->CanReadFileSystem(render_view_host->GetProcess()->GetID(),
                                  filesystem_id)) {
     *error = kSecurityError;
     return false;
   }
 
   IsolatedContext* context = IsolatedContext::GetInstance();
   base::FilePath relative_path =
       base::FilePath::FromUTF8Unsafe(filesystem_path);
   base::FilePath virtual_path = context->CreateVirtualRootPath(filesystem_id)
@@ skipping 155 matching lines @@
       is_directory_,
       base::Bind(&FileSystemEntryFunction::RegisterFileSystemsAndSendResponse,
                  this,
                  paths),
       base::Bind(&FileSystemEntryFunction::HandleWritableFileError, this));
 }
 
 void FileSystemEntryFunction::RegisterFileSystemsAndSendResponse(
     const std::vector<base::FilePath>& paths) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!render_view_host_)
+    return;
 
   CreateResponse();
   for (std::vector<base::FilePath>::const_iterator it = paths.begin();
        it != paths.end(); ++it) {
     AddEntryToResponse(*it, "");
   }
   SendResponse(true);
 }
 
 void FileSystemEntryFunction::CreateResponse() {
   DCHECK(!response_);
   response_ = new base::DictionaryValue();
   base::ListValue* list = new base::ListValue();
   response_->Set("entries", list);
   response_->SetBoolean("multiple", multiple_);
   SetResult(response_);
 }
 
 void FileSystemEntryFunction::AddEntryToResponse(
     const base::FilePath& path,
     const std::string& id_override) {
   DCHECK(response_);
+  DCHECK(render_view_host_);
   extensions::app_file_handler_util::GrantedFileEntry file_entry =
       extensions::app_file_handler_util::CreateFileEntry(
           profile(),
           GetExtension(),
           render_view_host_->GetProcess()->GetID(),
           path,
           is_directory_);
   base::ListValue* entries;
   bool success = response_->GetList("entries", &entries);
   DCHECK(success);
@@ skipping 70 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   std::string filesystem_id;
   if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
     error_ = kInvalidParameters;
     return false;
   }
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
+  DCHECK(render_view_host_);
   int renderer_id = render_view_host_->GetProcess()->GetID();
   bool is_writable = policy->CanReadWriteFileSystem(renderer_id,
                                                     filesystem_id);
 
   SetResult(new base::FundamentalValue(is_writable));
   return true;
 }
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
@@ skipping 541 matching lines @@
   if (needs_new_entry) {
     is_directory_ = file_entry->is_directory;
     CreateResponse();
     AddEntryToResponse(file_entry->path, file_entry->id);
   }
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions