Remove PNaCl's RequestFirstInstall, use resource throttle instead

chrome/renderer/pepper/pnacl_translation_resource_host.cc

 // Copyright 2013 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 "pnacl_translation_resource_host.h"
 
 #ifndef DISABLE_NACL
 #include "components/nacl/common/nacl_host_messages.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 
 using ppapi::TrackedCallback;
 using ppapi::PpapiGlobals;
 
 PnaclTranslationResourceHost::CacheRequestInfo::CacheRequestInfo(
     PP_Bool* hit,
     PP_FileHandle* handle,
     scoped_refptr<TrackedCallback> cb)
     : is_hit(hit), file_handle(handle), callback(cb) {}
 
 PnaclTranslationResourceHost::CacheRequestInfo::~CacheRequestInfo() {}
 
 PnaclTranslationResourceHost::PnaclTranslationResourceHost(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
     : io_message_loop_(io_message_loop), channel_(NULL) {}
 
 PnaclTranslationResourceHost::~PnaclTranslationResourceHost() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   CleanupCacheRequests();
-  CleanupEnsurePnaclRequests();
 }
 
 void PnaclTranslationResourceHost::OnFilterAdded(IPC::Channel* channel) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = channel;
 }
 
 void PnaclTranslationResourceHost::OnFilterRemoved() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = NULL;
 }
 
 void PnaclTranslationResourceHost::OnChannelClosing() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = NULL;
 }
 
 bool PnaclTranslationResourceHost::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PnaclTranslationResourceHost, message)
     IPC_MESSAGE_HANDLER(NaClViewMsg_NexeTempFileReply, OnNexeTempFileReply)
-    IPC_MESSAGE_HANDLER(NaClViewMsg_EnsurePnaclInstalledReply,
-                        OnEnsurePnaclInstalledReply)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PnaclTranslationResourceHost::RequestNexeFd(
     int render_view_id,
     PP_Instance instance,
     const nacl::PnaclCacheInfo& cache_info,
     PP_Bool* is_hit,
@@ skipping 95 matching lines @@
 void PnaclTranslationResourceHost::CleanupCacheRequests() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   for (CacheRequestInfoMap::iterator it = pending_cache_requests_.begin();
        it != pending_cache_requests_.end();
        ++it) {
     it->second.callback->PostAbort();
   }
   pending_cache_requests_.clear();
 }
 
-void PnaclTranslationResourceHost::EnsurePnaclInstalled(
-    PP_Instance instance,
-    scoped_refptr<TrackedCallback> callback) {
-  DCHECK(PpapiGlobals::Get()->
-         GetMainThreadMessageLoop()->BelongsToCurrentThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&PnaclTranslationResourceHost::SendEnsurePnaclInstalled,
-                 this, instance, callback));
-  return;
-}
-
-void PnaclTranslationResourceHost::SendEnsurePnaclInstalled(
-    PP_Instance instance,
-    scoped_refptr<TrackedCallback> callback) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  // If a request is already in, just queue this one and wait for notification.
-  // Hope that the request is not canceled.
-  if (pending_ensure_pnacl_requests_.size() > 0) {
-    pending_ensure_pnacl_requests_.push_back(callback);
-    return;
-  }
-  // Otherwise, try to send the request, then queue.
-  if (!channel_ || !channel_->Send(new NaClHostMsg_EnsurePnaclInstalled(
-          instance))) {
-    PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-        FROM_HERE,
-        base::Bind(&TrackedCallback::Run,
-                   callback,
-                   static_cast<int32_t>(PP_ERROR_FAILED)));
-    return;
-  }
-  pending_ensure_pnacl_requests_.push_back(callback);
-}
-
-void PnaclTranslationResourceHost::OnEnsurePnaclInstalledReply(
-    PP_Instance instance,
-    bool success) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  // Broadcast to all listeners.
-  for (EnsurePnaclInstalledList::iterator
-           i = pending_ensure_pnacl_requests_.begin(),
-           e = pending_ensure_pnacl_requests_.end();
-       i != e; ++i) {
-    if (TrackedCallback::IsPending(*i)) {
-      PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
-          FROM_HERE,
-          base::Bind(&TrackedCallback::Run,
-                     *i,
-                     static_cast<int32_t>(success ? PP_OK : PP_ERROR_FAILED)));
-    }
-  }
-  pending_ensure_pnacl_requests_.clear();
-}
-
-void PnaclTranslationResourceHost::CleanupEnsurePnaclRequests() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  for (EnsurePnaclInstalledList::iterator
-           i = pending_ensure_pnacl_requests_.begin(),
-           e = pending_ensure_pnacl_requests_.end();
-       i != e; ++i) {
-    (*i)->PostAbort();
-  }
-  pending_ensure_pnacl_requests_.clear();
-}
-
 #endif  // DISABLE_NACL