Issue 1092005

src/trusted/plugin/srpc/closure.h

 /*
  * Copyright 2008 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can
  * be found in the LICENSE file.
  */
 
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_SRPC_CLOSURE_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_SRPC_CLOSURE_H_
 
+#include <list>
 #include <string>
 
 #include "native_client/src/shared/npruntime/npmodule.h"
 #include "native_client/src/trusted/plugin/npinstance.h"
 #include "native_client/src/trusted/plugin/srpc/plugin.h"
 
 namespace nacl {
   class StreamBuffer;
 }
 
 namespace nacl_srpc {
 
 /*
  * Closure base class.  Following our C++ style rules, we have
  * an explicit Run method rather than overload the operator().
  *
  * This is pretty generic, actually, and not restricted to be used for
  * notification callbacks.
  */
 class Closure {
  public:
   Closure(Plugin* plugin, std::string url) :
     plugin_(plugin), url_(url), buffer_(NULL) {
     if (NULL != plugin_) {
       plugin_identifier_ =
           plugin_->GetPortablePluginInterface()->GetPluginIdentifier();
     }
   }
   virtual ~Closure() {}
+  /* TODO(adonovan): documentation, especially nullness invariants. */
   virtual void Run(NPStream *stream, const char *fname) = 0;
   virtual void Run(const char *url, const void* buffer, int32_t size) = 0;
   bool StartDownload();
   void set_plugin(nacl_srpc::Plugin* plugin) {
     plugin_ = plugin;
     plugin_identifier_ =
         plugin_->GetPortablePluginInterface()->GetPluginIdentifier();
   }
   void set_buffer(nacl::StreamBuffer* buffer) { buffer_ = buffer; }
   nacl::StreamBuffer* buffer() { return buffer_; }
  protected:
   Plugin* plugin() { return plugin_; }
+  const std::string& url() const { return url_; }
  private:
   Plugin* plugin_;
   std::string url_;
   nacl::StreamBuffer *buffer_;
   nacl_srpc::PluginIdentifier plugin_identifier_;
 };
 
 class LoadNaClAppNotify : public Closure {
  public:
-  LoadNaClAppNotify(Plugin *plugin, std::string url);
+  // Precondition: urls.list() > 0.
+  LoadNaClAppNotify(Plugin *plugin, const std::list<std::string>& urls);
   virtual ~LoadNaClAppNotify();
+  // Run(NULL, NULL) is called if the request failed; a new request
+  // for the fallback_urls should be initiated.
   virtual void Run(NPStream* stream, const char* fname);
   virtual void Run(const char *url, const void* buffer, int32_t size);
+ private:
+  // The list of alternative URLs to try should this request fail.
+  std::list<std::string> fallback_urls_;
 };
 
 class UrlAsNaClDescNotify : public Closure {
  public:
   UrlAsNaClDescNotify(Plugin *plugin, std::string url, void *callback_obj);
   virtual ~UrlAsNaClDescNotify();
   virtual void Run(NPStream *stream, const char *fname);
   virtual void Run(const char *url, const void* buffer, int32_t size);
  private:
   NPObject* np_callback_;
 };
 
 class NpGetUrlClosure : public Closure {
  public:
   NpGetUrlClosure(NPP npp, nacl::NPModule* module, std::string url);
   virtual ~NpGetUrlClosure();
   virtual void Run(NPStream* stream, const char* fname);
   virtual void Run(const char* url, const void* buffer, int32_t size);
 
  private:
   nacl::NPModule* module_;
   NPP npp_;
 };
 }  // namespace nacl_srpc
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_SRPC_CLOSURE_H_