// Copyright (c) 2009 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 CHROME_FRAME_URLMON_URL_REQUEST_H_
#define CHROME_FRAME_URLMON_URL_REQUEST_H_

#include <urlmon.h>
#include <atlbase.h>
#include <atlcom.h>
#include <map>
#include <string>

#include "base/lock.h"
#include "base/scoped_comptr_win.h"
#include "base/thread.h"
#include "base/waitable_event.h"
#include "chrome_frame/plugin_url_request.h"
#include "chrome_frame/urlmon_moniker.h"
#include "chrome_frame/utils.h"

class UrlmonUrlRequest;

class RequestDataForUrl {
 public:
  RequestDataForUrl(RequestData* data, const std::wstring& url)
      : request_data_(data), url_(url) {
  }
  ~RequestDataForUrl() {
  }

  const std::wstring& url() const {
    return url_;
  }

  RequestData* request_data() const {
    return request_data_;
  }

 protected:
  scoped_refptr<RequestData> request_data_;
  std::wstring url_;
};

class UrlmonUrlRequestManager
    : public PluginUrlRequestManager,
      public PluginUrlRequestDelegate {
 public:
  UrlmonUrlRequestManager();
  ~UrlmonUrlRequestManager();

  // Use cached data when Chrome request this url.
  // Used from ChromeActiveDocument's implementation of IPersistMoniker::Load().
  void UseRequestDataForUrl(RequestData* data, const std::wstring& url);
  void StealMonikerFromRequest(int request_id, IMoniker** moniker);
  void SetErrorDialogsParentWindow(HWND window);
 private:
  friend class MessageLoop;
  friend struct RunnableMethodTraits<UrlmonUrlRequestManager>;
  static bool ImplementsThreadSafeReferenceCounting() { return true; }
  void AddRef() {}
  void Release() {}

  // PluginUrlRequestManager implementation.
  virtual bool IsThreadSafe();
  virtual void StartRequest(int request_id,
    const IPC::AutomationURLRequest& request_info);
  virtual void ReadRequest(int request_id, int bytes_to_read);
  virtual void EndRequest(int request_id);
  virtual void StopAll();

  // PluginUrlRequestDelegate implementation
  virtual void OnResponseStarted(int request_id, const char* mime_type,
    const char* headers, int size, base::Time last_modified,
    const std::string& redirect_url, int redirect_status);
  virtual void OnReadComplete(int request_id, const void* buffer, int len);
  virtual void OnResponseEnd(int request_id, const URLRequestStatus& status);

  bool ExecuteInWorkerThread(const tracked_objects::Location& from_here,
                             Task* task);
  // Methods executed in worker thread.
  void StartRequestWorker(int request_id,
                          const IPC::AutomationURLRequest& request_info,
                          RequestDataForUrl* use_request);
  void ReadRequestWorker(int request_id, int bytes_to_read);
  void EndRequestWorker(int request_id);
  void StopAllWorker();
  void StealMonikerFromRequestWorker(int request_id, IMoniker** moniker,
                                     base::WaitableEvent* done);

  // Map for (request_id <-> UrlmonUrlRequest)
  typedef std::map<int, scoped_refptr<UrlmonUrlRequest> > RequestMap;
  RequestMap request_map_;
  scoped_refptr<UrlmonUrlRequest> LookupRequest(int request_id);

  scoped_ptr<RequestDataForUrl> request_data_for_url_;
  STAThread worker_thread_;
  base::WaitableEvent map_empty_;
  bool stopping_;
  Lock worker_thread_access_;
  HWND err_dialog_parent_wnd_;
};

#endif  // CHROME_FRAME_URLMON_URL_REQUEST_H_