// Copyright 2014 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.

#ifndef MOJO_APPLICATION_MANAGER_APPLICATION_LOADER_H_
#define MOJO_APPLICATION_MANAGER_APPLICATION_LOADER_H_

#include "base/memory/ref_counted.h"
#include "mojo/application_manager/application_manager_export.h"
#include "mojo/public/cpp/system/core.h"
#include "mojo/services/public/interfaces/network/url_loader.mojom.h"
#include "url/gurl.h"

namespace mojo {

class ApplicationManager;

// Interface to allowing loading behavior to be established for schemes,
// specific urls or as the default.
// A ApplicationLoader is responsible to using whatever mechanism is appropriate
// to load the application at url.
// The handle to the shell is passed to that application so it can bind it to
// a Shell instance. This will give the Application a way to connect to other
// apps and services.
class MOJO_APPLICATION_MANAGER_EXPORT ApplicationLoader {
 public:
  class MOJO_APPLICATION_MANAGER_EXPORT LoadCallbacks
      : public base::RefCounted<LoadCallbacks> {
   public:
    // Register the requested application with ApplicationManager. If the
    // returned handle is valid, it should be used to implement the
    // mojo::Application interface.
    virtual ScopedMessagePipeHandle RegisterApplication() = 0;

    // Load the requested application with a content handler.
    virtual void LoadWithContentHandler(const GURL& content_handler_url,
                                        URLResponsePtr url_response) = 0;

   protected:
    friend base::RefCounted<LoadCallbacks>;
    virtual ~LoadCallbacks() {}
  };

  // Implements RegisterApplication() by returning a handle that was specified
  // at construction time. LoadWithContentHandler() is not supported.
  class MOJO_APPLICATION_MANAGER_EXPORT SimpleLoadCallbacks
      : public LoadCallbacks {
   public:
    SimpleLoadCallbacks(ScopedMessagePipeHandle shell_handle);
    virtual ScopedMessagePipeHandle RegisterApplication() override;
    virtual void LoadWithContentHandler(const GURL& content_handler_url,
                                        URLResponsePtr response) override;

   private:
    ScopedMessagePipeHandle shell_handle_;
    virtual ~SimpleLoadCallbacks();
  };

  virtual ~ApplicationLoader() {}

  // Load the application named |url|. Applications can be loaded two ways:
  //
  // 1. |url| can refer directly to a Mojo application. In this case, call
  //    callbacks->RegisterApplication(). The returned handle should be used to
  //    implement the mojo.Application interface. Note that the returned handle
  //    can be invalid in the case where the application has already been
  //    loaded.
  //
  // 2. |url| can refer to some content that can be handled by some other Mojo
  //    application. In this case, call callbacks->LoadWithContentHandler() and
  //    specify the URL of the application that should handle the content.
  //    The specified application must implement the mojo.ContentHandler
  //    interface.
  virtual void Load(ApplicationManager* application_manager,
                    const GURL& url,
                    scoped_refptr<LoadCallbacks> callbacks) = 0;

  // Called when the Application exits.
  virtual void OnApplicationError(ApplicationManager* manager,
                                  const GURL& url) = 0;

 protected:
  ApplicationLoader() {}
};

}  // namespace mojo

#endif  // MOJO_APPLICATION_MANAGER_APPLICATION_LOADER_H_