// Copyright (c) 2012 The Chromium Embedded Framework 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 <vector>

// Include this first to avoid type conflicts with CEF headers.
#include "tests/unittests/chromium_includes.h"

#include "base/files/scoped_temp_dir.h"
#include "base/synchronization/waitable_event.h"

#include "include/base/cef_bind.h"
#include "include/base/cef_logging.h"
#include "include/base/cef_ref_counted.h"
#include "include/cef_cookie.h"
#include "include/cef_scheme.h"
#include "include/wrapper/cef_closure_task.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "tests/unittests/test_handler.h"
#include "tests/unittests/test_suite.h"

namespace {

const char* kTestUrl = "http://www.test.com/path/to/cookietest/foo.html";
const char* kTestDomain = "www.test.com";
const char* kTestPath = "/path/to/cookietest";

typedef std::vector<CefCookie> CookieVector;

void IOT_Set(CefRefPtr<CefCookieManager> manager,
             const CefString& url, CookieVector* cookies,
             base::WaitableEvent* event) {
  CookieVector::const_iterator it = cookies->begin();
  for (; it != cookies->end(); ++it)
    EXPECT_TRUE(manager->SetCookie(url, *it));
  event->Signal();
}

void IOT_Delete(CefRefPtr<CefCookieManager> manager,
                const CefString& url, const CefString& cookie_name,
                base::WaitableEvent* event) {
  EXPECT_TRUE(manager->DeleteCookies(url, cookie_name));
  event->Signal();
}

class TestVisitor : public CefCookieVisitor {
 public:
  TestVisitor(CookieVector* cookies, bool deleteCookies,
              base::WaitableEvent* event)
    : cookies_(cookies),
      delete_cookies_(deleteCookies),
      event_(event) {
  }
  ~TestVisitor() override {
    event_->Signal();
  }

  bool Visit(const CefCookie& cookie, int count, int total,
             bool& deleteCookie) override {
    cookies_->push_back(cookie);
    if (delete_cookies_)
      deleteCookie = true;
    return true;
  }

  CookieVector* cookies_;
  bool delete_cookies_;
  base::WaitableEvent* event_;

  IMPLEMENT_REFCOUNTING(TestVisitor);
};

// Set the cookies.
void SetCookies(CefRefPtr<CefCookieManager> manager,
                const CefString& url, CookieVector& cookies,
                base::WaitableEvent& event) {
  CefPostTask(TID_IO, base::Bind(IOT_Set, manager, url, &cookies, &event));
  event.Wait();
}

// Delete the cookie.
void DeleteCookies(CefRefPtr<CefCookieManager> manager,
                   const CefString& url, const CefString& cookie_name,
                   base::WaitableEvent& event) {
  CefPostTask(TID_IO,
      base::Bind(IOT_Delete, manager, url, cookie_name, &event));
  event.Wait();
}

// Create a test cookie. If |withDomain| is true a domain cookie will be
// created, otherwise a host cookie will be created.
void CreateCookie(CefRefPtr<CefCookieManager> manager,
                  CefCookie& cookie, bool withDomain,
                  bool sessionCookie,
                  base::WaitableEvent& event) {
  CefString(&cookie.name).FromASCII("my_cookie");
  CefString(&cookie.value).FromASCII("My Value");
  if (withDomain)
    CefString(&cookie.domain).FromASCII(kTestDomain);
  CefString(&cookie.path).FromASCII(kTestPath);
  if (!sessionCookie) {
    cookie.has_expires = true;
    cookie.expires.year = 2200;
    cookie.expires.month = 4;
    cookie.expires.day_of_week = 5;
    cookie.expires.day_of_month = 11;
  }

  CookieVector cookies;
  cookies.push_back(cookie);

  SetCookies(manager, kTestUrl, cookies, event);
}

// Retrieve the test cookie. If |withDomain| is true check that the cookie
// is a domain cookie, otherwise a host cookie. if |deleteCookies| is true
// the cookie will be deleted when it's retrieved.
void GetCookie(CefRefPtr<CefCookieManager> manager,
               const CefCookie& cookie, bool withDomain,
               base::WaitableEvent& event, bool deleteCookies) {
  CookieVector cookies;

  // Get the cookie and delete it.
  EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
      new TestVisitor(&cookies, deleteCookies, &event)));
  event.Wait();

  EXPECT_EQ((CookieVector::size_type)1, cookies.size());

  const CefCookie& cookie_read = cookies[0];
  EXPECT_EQ(CefString(&cookie_read.name), "my_cookie");
  EXPECT_EQ(CefString(&cookie_read.value), "My Value");
  if (withDomain)
    EXPECT_EQ(CefString(&cookie_read.domain), ".www.test.com");
  else
    EXPECT_EQ(CefString(&cookie_read.domain), kTestDomain);
  EXPECT_EQ(CefString(&cookie_read.path), kTestPath);
  EXPECT_EQ(cookie.has_expires, cookie_read.has_expires);
  EXPECT_EQ(cookie.expires.year, cookie_read.expires.year);
  EXPECT_EQ(cookie.expires.month, cookie_read.expires.month);
  EXPECT_EQ(cookie.expires.day_of_week, cookie_read.expires.day_of_week);
  EXPECT_EQ(cookie.expires.day_of_month, cookie_read.expires.day_of_month);
  EXPECT_EQ(cookie.expires.hour, cookie_read.expires.hour);
  EXPECT_EQ(cookie.expires.minute, cookie_read.expires.minute);
  EXPECT_EQ(cookie.expires.second, cookie_read.expires.second);
  EXPECT_EQ(cookie.expires.millisecond, cookie_read.expires.millisecond);
}

// Visit URL cookies.
void VisitUrlCookies(CefRefPtr<CefCookieManager> manager,
                     const CefString& url,
                     bool includeHttpOnly,
                     CookieVector& cookies,
                     bool deleteCookies,
                     base::WaitableEvent& event) {
  EXPECT_TRUE(manager->VisitUrlCookies(url, includeHttpOnly,
      new TestVisitor(&cookies, deleteCookies, &event)));
  event.Wait();
}

// Visit all cookies.
void VisitAllCookies(CefRefPtr<CefCookieManager> manager,
                     CookieVector& cookies,
                     bool deleteCookies,
                     base::WaitableEvent& event) {
  EXPECT_TRUE(manager->VisitAllCookies(
      new TestVisitor(&cookies, deleteCookies, &event)));
  event.Wait();
}

// Verify that no cookies exist. If |withUrl| is true it will only check for
// cookies matching the URL.
void VerifyNoCookies(CefRefPtr<CefCookieManager> manager,
                     base::WaitableEvent& event, bool withUrl) {
  CookieVector cookies;

  // Verify that the cookie has been deleted.
  if (withUrl) {
    EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
        new TestVisitor(&cookies, false, &event)));
  } else {
    EXPECT_TRUE(manager->VisitAllCookies(
        new TestVisitor(&cookies, false, &event)));
  }
  event.Wait();

  EXPECT_EQ((CookieVector::size_type)0, cookies.size());
}

// Delete all system cookies.
void DeleteAllCookies(CefRefPtr<CefCookieManager> manager,
                      base::WaitableEvent& event) {
  CefPostTask(TID_IO,
      base::Bind(IOT_Delete, manager, CefString(), CefString(), &event));
  event.Wait();
}

void TestDomainCookie(CefRefPtr<CefCookieManager> manager) {
  base::WaitableEvent event(false, false);
  CefCookie cookie;

  // Create a domain cookie.
  CreateCookie(manager, cookie, true, false, event);

  // Retrieve, verify and delete the domain cookie.
  GetCookie(manager, cookie, true, event, true);

  // Verify that the cookie was deleted.
  VerifyNoCookies(manager, event, true);
}

void TestHostCookie(CefRefPtr<CefCookieManager> manager) {
  base::WaitableEvent event(false, false);
  CefCookie cookie;

  // Create a host cookie.
  CreateCookie(manager, cookie, false, false, event);

  // Retrieve, verify and delete the host cookie.
  GetCookie(manager, cookie, false, event, true);

  // Verify that the cookie was deleted.
  VerifyNoCookies(manager, event, true);
}

void TestMultipleCookies(CefRefPtr<CefCookieManager> manager) {
  base::WaitableEvent event(false, false);
  std::stringstream ss;
  int i;

  CookieVector cookies;

  const int kNumCookies = 4;

  // Create the cookies.
  for (i = 0; i < kNumCookies; i++) {
    CefCookie cookie;

    ss << "my_cookie" << i;
    CefString(&cookie.name).FromASCII(ss.str().c_str());
    ss.str("");
    ss << "My Value " << i;
    CefString(&cookie.value).FromASCII(ss.str().c_str());
    ss.str("");

    cookies.push_back(cookie);
  }

  // Set the cookies.
  SetCookies(manager, kTestUrl, cookies, event);
  cookies.clear();

  // Get the cookies without deleting them.
  VisitUrlCookies(manager, kTestUrl, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)kNumCookies, cookies.size());

  CookieVector::const_iterator it = cookies.begin();
  for (i = 0; it != cookies.end(); ++it, ++i) {
    const CefCookie& cookie = *it;

    ss << "my_cookie" << i;
    EXPECT_EQ(CefString(&cookie.name), ss.str());
    ss.str("");
    ss << "My Value " << i;
    EXPECT_EQ(CefString(&cookie.value), ss.str());
    ss.str("");
  }

  cookies.clear();

  // Delete the 2nd cookie.
  DeleteCookies(manager, kTestUrl, CefString("my_cookie1"), event);

  // Verify that the cookie has been deleted.
  VisitUrlCookies(manager, kTestUrl, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)3, cookies.size());
  EXPECT_EQ(CefString(&cookies[0].name), "my_cookie0");
  EXPECT_EQ(CefString(&cookies[1].name), "my_cookie2");
  EXPECT_EQ(CefString(&cookies[2].name), "my_cookie3");

  cookies.clear();

  // Delete the rest of the cookies.
  DeleteCookies(manager, kTestUrl, CefString(), event);

  // Verify that the cookies have been deleted.
  VisitUrlCookies(manager, kTestUrl, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)0, cookies.size());

  // Create the cookies.
  for (i = 0; i < kNumCookies; i++) {
    CefCookie cookie;

    ss << "my_cookie" << i;
    CefString(&cookie.name).FromASCII(ss.str().c_str());
    ss.str("");
    ss << "My Value " << i;
    CefString(&cookie.value).FromASCII(ss.str().c_str());
    ss.str("");

    cookies.push_back(cookie);
  }

  // Delete all of the cookies using the visitor.
  VisitUrlCookies(manager, kTestUrl, false, cookies, true, event);

  cookies.clear();

  // Verify that the cookies have been deleted.
  VisitUrlCookies(manager, kTestUrl, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)0, cookies.size());
}

void TestAllCookies(CefRefPtr<CefCookieManager> manager) {
  base::WaitableEvent event(false, false);
  CookieVector cookies;

  // Delete all system cookies just in case something is left over from a
  // different test.
  DeleteCookies(manager, CefString(), CefString(), event);

  // Verify that all system cookies have been deleted.
  VisitAllCookies(manager, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)0, cookies.size());

  // Create cookies with 2 separate hosts.
  CefCookie cookie1;
  const char* kUrl1 = "http://www.foo.com";
  CefString(&cookie1.name).FromASCII("my_cookie1");
  CefString(&cookie1.value).FromASCII("My Value 1");

  cookies.push_back(cookie1);
  SetCookies(manager,  kUrl1, cookies, event);
  cookies.clear();

  CefCookie cookie2;
  const char* kUrl2 = "http://www.bar.com";
  CefString(&cookie2.name).FromASCII("my_cookie2");
  CefString(&cookie2.value).FromASCII("My Value 2");

  cookies.push_back(cookie2);
  SetCookies(manager,  kUrl2, cookies, event);
  cookies.clear();

  // Verify that all system cookies can be retrieved.
  VisitAllCookies(manager, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)2, cookies.size());
  EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1");
  EXPECT_EQ(CefString(&cookies[0].value), "My Value 1");
  EXPECT_EQ(CefString(&cookies[0].domain), "www.foo.com");
  EXPECT_EQ(CefString(&cookies[1].name), "my_cookie2");
  EXPECT_EQ(CefString(&cookies[1].value), "My Value 2");
  EXPECT_EQ(CefString(&cookies[1].domain), "www.bar.com");
  cookies.clear();

  // Verify that the cookies can be retrieved separately.
  VisitUrlCookies(manager, kUrl1, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)1, cookies.size());
  EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1");
  EXPECT_EQ(CefString(&cookies[0].value), "My Value 1");
  EXPECT_EQ(CefString(&cookies[0].domain), "www.foo.com");
  cookies.clear();

  VisitUrlCookies(manager, kUrl2, false, cookies, false, event);

  EXPECT_EQ((CookieVector::size_type)1, cookies.size());
  EXPECT_EQ(CefString(&cookies[0].name), "my_cookie2");
  EXPECT_EQ(CefString(&cookies[0].value), "My Value 2");
  EXPECT_EQ(CefString(&cookies[0].domain), "www.bar.com");
  cookies.clear();

  // Delete all of the system cookies.
  DeleteAllCookies(manager, event);

  // Verify that all system cookies have been deleted.
  VerifyNoCookies(manager, event, false);
}

void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
                         const CefString& original_dir) {
  base::WaitableEvent event(false, false);
  CefCookie cookie;

  base::ScopedTempDir temp_dir;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  // Delete all of the system cookies.
  DeleteAllCookies(manager, event);

  // Set the new temporary directory as the storage location.
  EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value(), false));

  // Wait for the storage location change to complete on the IO thread.
  WaitForIOThread();

  // Verify that no cookies exist.
  VerifyNoCookies(manager, event, true);

  // Create a domain cookie.
  CreateCookie(manager, cookie, true, false, event);

  // Retrieve and verify the domain cookie.
  GetCookie(manager, cookie, true, event, false);

  // Restore the original storage location.
  EXPECT_TRUE(manager->SetStoragePath(original_dir, false));

  // Wait for the storage location change to complete on the IO thread.
  WaitForIOThread();

  // Verify that no cookies exist.
  VerifyNoCookies(manager, event, true);

  // Set the new temporary directory as the storage location.
  EXPECT_TRUE(manager->SetStoragePath(temp_dir.path().value(), false));

  // Wait for the storage location change to complete on the IO thread.
  WaitForIOThread();

  // Retrieve and verify the domain cookie that was set previously.
  GetCookie(manager, cookie, true, event, false);

  // Restore the original storage location.
  EXPECT_TRUE(manager->SetStoragePath(original_dir, false));

  // Wait for the storage location change to complete on the IO thread.
  WaitForIOThread();
}

}  // namespace

// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieGlobal) {
  CefRefPtr<CefCookieManager> manager = CefCookieManager::GetGlobalManager();
  EXPECT_TRUE(manager.get());

  TestDomainCookie(manager);
}

// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieInMemory) {
  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(CefString(), false);
  EXPECT_TRUE(manager.get());

  TestDomainCookie(manager);
}

// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieOnDisk) {
  base::ScopedTempDir temp_dir;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);
  EXPECT_TRUE(manager.get());

  TestDomainCookie(manager);
}

// Test creation of a host cookie.
TEST(CookieTest, HostCookieGlobal) {
  CefRefPtr<CefCookieManager> manager = CefCookieManager::GetGlobalManager();
  EXPECT_TRUE(manager.get());

  TestHostCookie(manager);
}

// Test creation of a host cookie.
TEST(CookieTest, HostCookieInMemory) {
  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(CefString(), false);
  EXPECT_TRUE(manager.get());

  TestHostCookie(manager);
}

// Test creation of a host cookie.
TEST(CookieTest, HostCookieOnDisk) {
  base::ScopedTempDir temp_dir;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);
  EXPECT_TRUE(manager.get());

  TestHostCookie(manager);
}

// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesGlobal) {
  CefRefPtr<CefCookieManager> manager = CefCookieManager::GetGlobalManager();
  EXPECT_TRUE(manager.get());

  TestMultipleCookies(manager);
}

// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesInMemory) {
  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(CefString(), false);
  EXPECT_TRUE(manager.get());

  TestMultipleCookies(manager);
}

// Test creation of multiple cookies.
TEST(CookieTest, MultipleCookiesOnDisk) {
  base::ScopedTempDir temp_dir;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);
  EXPECT_TRUE(manager.get());

  TestMultipleCookies(manager);
}

TEST(CookieTest, AllCookiesGlobal) {
  CefRefPtr<CefCookieManager> manager = CefCookieManager::GetGlobalManager();
  EXPECT_TRUE(manager.get());

  TestAllCookies(manager);
}

TEST(CookieTest, AllCookiesInMemory) {
  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(CefString(), false);
  EXPECT_TRUE(manager.get());

  TestAllCookies(manager);
}

TEST(CookieTest, AllCookiesOnDisk) {
  base::ScopedTempDir temp_dir;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);
  EXPECT_TRUE(manager.get());

  TestAllCookies(manager);
}

TEST(CookieTest, ChangeDirectoryGlobal) {
  CefRefPtr<CefCookieManager> manager = CefCookieManager::GetGlobalManager();
  EXPECT_TRUE(manager.get());

  std::string cache_path;
  CefTestSuite::GetCachePath(cache_path);

  TestChangeDirectory(manager, cache_path);
}

TEST(CookieTest, ChangeDirectoryCreated) {
  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(CefString(), false);
  EXPECT_TRUE(manager.get());

  TestChangeDirectory(manager, CefString());
}


namespace {

class TestCompletionCallback : public CefCompletionCallback {
 public:
  explicit TestCompletionCallback(base::WaitableEvent* event)
    : event_(event) {}

  void OnComplete() override {
    event_->Signal();
  }

 private:
  base::WaitableEvent* event_;

  IMPLEMENT_REFCOUNTING(TestCompletionCallback);
};

}  // namespace

TEST(CookieTest, SessionCookieNoPersist) {
  base::ScopedTempDir temp_dir;
  base::WaitableEvent event(false, false);
  CefCookie cookie;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);
  EXPECT_TRUE(manager.get());

  // Create a session cookie.
  CreateCookie(manager, cookie, true, true, event);

  // Retrieve and verify the cookie.
  GetCookie(manager, cookie, true, event, false);

  // Flush the cookie store to disk.
  manager->FlushStore(new TestCompletionCallback(&event));
  event.Wait();
  
  // Create a new manager to read the same cookie store.
  manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), false);

  // Verify that the cookie doesn't exist.
  VerifyNoCookies(manager, event, true);
}

TEST(CookieTest, SessionCookieWillPersist) {
  base::ScopedTempDir temp_dir;
  base::WaitableEvent event(false, false);
  CefCookie cookie;

  // Create a new temporary directory.
  EXPECT_TRUE(temp_dir.CreateUniqueTempDir());

  CefRefPtr<CefCookieManager> manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), true);
  EXPECT_TRUE(manager.get());

  // Create a session cookie.
  CreateCookie(manager, cookie, true, true, event);

  // Retrieve and verify the cookie.
  GetCookie(manager, cookie, true, event, false);

  // Flush the cookie store to disk.
  manager->FlushStore(new TestCompletionCallback(&event));
  event.Wait();
  
  // Create a new manager to read the same cookie store.
  manager =
      CefCookieManager::CreateManager(temp_dir.path().value(), true);

  // Verify that the cookie exists.
  GetCookie(manager, cookie, true, event, false);
}


namespace {

const char* kCookieJSUrl1 = "http://tests/cookie1.html";
const char* kCookieJSUrl2 = "http://tests/cookie2.html";

class CookieTestJSHandler : public TestHandler {
 public:
  class RequestContextHandler : public CefRequestContextHandler {
   public:
    explicit RequestContextHandler(CookieTestJSHandler* handler)
        : handler_(handler) {}

    CefRefPtr<CefCookieManager> GetCookieManager() override {
      EXPECT_TRUE(handler_);
      EXPECT_TRUE(CefCurrentlyOn(TID_IO));

      if (url_ == kCookieJSUrl1) {
        // Return the first cookie manager.
        handler_->got_cookie_manager1_.yes();
        return handler_->manager1_;
      } else {
        // Return the second cookie manager.
        handler_->got_cookie_manager2_.yes();
        return handler_->manager2_;
      }
    }

    void SetURL(const std::string& url) {
      url_ = url;
    }

    void Detach() {
      handler_ = NULL;
    }

   private:
    std::string url_;
    CookieTestJSHandler* handler_;

    IMPLEMENT_REFCOUNTING(RequestContextHandler);
  };

  CookieTestJSHandler() {}

  void RunTest() override {
    // Create =new in-memory managers.
    manager1_ = CefCookieManager::CreateManager(CefString(), false);
    manager2_ = CefCookieManager::CreateManager(CefString(), false);

    std::string page =
        "<html><head>"
        "<script>"
        "document.cookie='name1=value1';"
        "</script>"
        "</head><body>COOKIE TEST1</body></html>";
    AddResource(kCookieJSUrl1, page, "text/html");

    page =
        "<html><head>"
        "<script>"
        "document.cookie='name2=value2';"
        "</script>"
        "</head><body>COOKIE TEST2</body></html>";
    AddResource(kCookieJSUrl2, page, "text/html");

    context_handler_ = new RequestContextHandler(this);
    context_handler_->SetURL(kCookieJSUrl1);

    // Create the browser
    CreateBrowser(kCookieJSUrl1,
        CefRequestContext::CreateContext(context_handler_.get()));

    // Time out the test after a reasonable period of time.
    SetTestTimeout();
  }

  void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                 CefRefPtr<CefFrame> frame,
                 int httpStatusCode) override {
    std::string url = frame->GetURL();
    if (url == kCookieJSUrl1) {
      got_load_end1_.yes();
      VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);

      // Go to the next URL
      context_handler_->SetURL(kCookieJSUrl2);
      frame->LoadURL(kCookieJSUrl2);
    } else {
      got_load_end2_.yes();
      VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_);

      DestroyTest();
    }
  }

  void DestroyTest() override {
    context_handler_->Detach();
    context_handler_ = NULL;

    TestHandler::DestroyTest();
  }

  // Verify that the cookie was set successfully.
  void VerifyCookie(CefRefPtr<CefCookieManager> manager,
                    const std::string& url,
                    const std::string& name,
                    const std::string& value,
                    TrackCallback& callback) {
    base::WaitableEvent event(false, false);
    CookieVector cookies;

    // Get the cookie.
    VisitUrlCookies(manager, url, false, cookies, false, event);

    if (cookies.size() == 1 && CefString(&cookies[0].name) == name &&
        CefString(&cookies[0].value) == value) {
      callback.yes();
    }
  }

  CefRefPtr<RequestContextHandler> context_handler_;

  CefRefPtr<CefCookieManager> manager1_;
  CefRefPtr<CefCookieManager> manager2_;

  TrackCallback got_cookie_manager1_;
  TrackCallback got_cookie_manager2_;
  TrackCallback got_load_end1_;
  TrackCallback got_load_end2_;
  TrackCallback got_cookie1_;
  TrackCallback got_cookie2_;
};

}  // namespace

// Verify use of multiple cookie managers vis JS.
TEST(CookieTest, GetCookieManagerJS) {
  CefRefPtr<CookieTestJSHandler> handler = new CookieTestJSHandler();
  handler->ExecuteTest();

  EXPECT_TRUE(handler->got_cookie_manager1_);
  EXPECT_TRUE(handler->got_cookie_manager2_);
  EXPECT_TRUE(handler->got_load_end1_);
  EXPECT_TRUE(handler->got_load_end2_);
  EXPECT_TRUE(handler->got_cookie1_);
  EXPECT_TRUE(handler->got_cookie2_);

  ReleaseAndWaitForDestructor(handler);
}


namespace {

class CookieTestSchemeHandler : public TestHandler {
 public:
  class SchemeHandler : public CefResourceHandler {
   public:
    explicit SchemeHandler(CookieTestSchemeHandler* handler)
        : handler_(handler),
          offset_(0) {}

    bool ProcessRequest(CefRefPtr<CefRequest> request,
                        CefRefPtr<CefCallback> callback) override {
      std::string url = request->GetURL();
      if (url == handler_->url1_) {
        content_ = "<html><body>COOKIE TEST1</body></html>";
        cookie_ = "name1=value1";
        handler_->got_process_request1_.yes();
      } else if (url == handler_->url2_) {
        content_ = "<html><body>COOKIE TEST2</body></html>";
        cookie_ = "name2=value2";
        handler_->got_process_request2_.yes();
      } else if (url == handler_->url3_) {
        content_ = "<html><body>COOKIE TEST3</body></html>";
        handler_->got_process_request3_.yes();

        // Verify that the cookie was passed in.
        CefRequest::HeaderMap headerMap;
        request->GetHeaderMap(headerMap);
        CefRequest::HeaderMap::iterator it = headerMap.find("Cookie");
        if (it != headerMap.end() && it->second == "name2=value2")
          handler_->got_process_request_cookie_.yes();

      }
      callback->Continue();
      return true;
    }

    void GetResponseHeaders(CefRefPtr<CefResponse> response,
                            int64& response_length,
                            CefString& redirectUrl) override {
      response_length = content_.size();

      response->SetStatus(200);
      response->SetMimeType("text/html");

      if (!cookie_.empty()) {
        CefResponse::HeaderMap headerMap;
        response->GetHeaderMap(headerMap);
        headerMap.insert(std::make_pair("Set-Cookie", cookie_));
        response->SetHeaderMap(headerMap);
      }
    }

    bool ReadResponse(void* data_out,
                      int bytes_to_read,
                      int& bytes_read,
                      CefRefPtr<CefCallback> callback) override {
      bool has_data = false;
      bytes_read = 0;

      size_t size = content_.size();
      if (offset_ < size) {
        int transfer_size =
            std::min(bytes_to_read, static_cast<int>(size - offset_));
        memcpy(data_out, content_.c_str() + offset_, transfer_size);
        offset_ += transfer_size;

        bytes_read = transfer_size;
        has_data = true;
      }

      return has_data;
    }

    void Cancel() override {
    }

   private:
    CookieTestSchemeHandler* handler_;
    std::string content_;
    size_t offset_;
    std::string cookie_;

    IMPLEMENT_REFCOUNTING(SchemeHandler);
  };

  class SchemeHandlerFactory : public CefSchemeHandlerFactory {
   public:
    explicit SchemeHandlerFactory(CookieTestSchemeHandler* handler)
        : handler_(handler) {}

    CefRefPtr<CefResourceHandler> Create(
        CefRefPtr<CefBrowser> browser,
        CefRefPtr<CefFrame> frame,
        const CefString& scheme_name,
        CefRefPtr<CefRequest> request) override {
      std::string url = request->GetURL();
      if (url == handler_->url3_) {
        // Verify that the cookie was not passed in.
        CefRequest::HeaderMap headerMap;
        request->GetHeaderMap(headerMap);
        CefRequest::HeaderMap::iterator it = headerMap.find("Cookie");
        if (it != headerMap.end() && it->second == "name2=value2")
          handler_->got_create_cookie_.yes();
      }
                                                 
      return new SchemeHandler(handler_);
    }

   private:
    CookieTestSchemeHandler* handler_;

    IMPLEMENT_REFCOUNTING(SchemeHandlerFactory);
  };

  class RequestContextHandler : public CefRequestContextHandler {
   public:
    explicit RequestContextHandler(CookieTestSchemeHandler* handler)
        : handler_(handler) {}

    CefRefPtr<CefCookieManager> GetCookieManager() override {
      EXPECT_TRUE(handler_);
      EXPECT_TRUE(CefCurrentlyOn(TID_IO));

      if (url_ == handler_->url1_) {
        // Return the first cookie manager.
        handler_->got_cookie_manager1_.yes();
        return handler_->manager1_;
      } else {
        // Return the second cookie manager.
        handler_->got_cookie_manager2_.yes();
        return handler_->manager2_;
      }
    }

    void SetURL(const std::string& url) {
      url_ = url;
    }

    void Detach() {
      handler_ = NULL;
    }

   private:
    std::string url_;
    CookieTestSchemeHandler* handler_;

    IMPLEMENT_REFCOUNTING(RequestContextHandler);
  };

  CookieTestSchemeHandler(const std::string& scheme) : scheme_(scheme) {
    url1_ = scheme + "://cookie-tests/cookie1.html";
    url2_ = scheme + "://cookie-tests/cookie2.html";
    url3_ = scheme + "://cookie-tests/cookie3.html";
  }

  void RunTest() override {
    // Create new in-memory managers.
    manager1_ = CefCookieManager::CreateManager(CefString(), false);
    manager2_ = CefCookieManager::CreateManager(CefString(), false);

    if (scheme_ != "http") {
      std::vector<CefString> schemes;
      schemes.push_back("http");
      schemes.push_back("https");
      schemes.push_back(scheme_);

      manager1_->SetSupportedSchemes(schemes);
      manager2_->SetSupportedSchemes(schemes);
    }

    // Register the scheme handler.
    CefRegisterSchemeHandlerFactory(scheme_, "cookie-tests",
        new SchemeHandlerFactory(this));

    context_handler_ = new RequestContextHandler(this);
    context_handler_->SetURL(url1_);

    // Create the browser
    CreateBrowser(url1_,
        CefRequestContext::CreateContext(context_handler_.get()));

    // Time out the test after a reasonable period of time.
    SetTestTimeout();
  }

  void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                 CefRefPtr<CefFrame> frame,
                 int httpStatusCode) override {
    std::string url = frame->GetURL();
    if (url == url1_) {
      got_load_end1_.yes();
      VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);

      // Go to the next URL
      context_handler_->SetURL(url2_);
      frame->LoadURL(url2_);
    } else if (url == url2_) {
      got_load_end2_.yes();
      VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_);

      // Go to the next URL
      context_handler_->SetURL(url3_);
      frame->LoadURL(url3_);
    } else {
      got_load_end3_.yes();
      VerifyCookie(manager2_, url, "name2", "value2", got_cookie3_);

      // Unregister the scheme handler.
      CefRegisterSchemeHandlerFactory(scheme_, "cookie-tests", NULL);

      DestroyTest();
    }
  }

   void DestroyTest() override {
     context_handler_->Detach();
     context_handler_ = NULL;

     TestHandler::DestroyTest();
   }

  // Verify that the cookie was set successfully.
  void VerifyCookie(CefRefPtr<CefCookieManager> manager,
                    const std::string& url,
                    const std::string& name,
                    const std::string& value,
                    TrackCallback& callback) {
    base::WaitableEvent event(false, false);
    CookieVector cookies;

    // Get the cookie.
    VisitUrlCookies(manager, url, false, cookies, false, event);

    if (cookies.size() == 1 && CefString(&cookies[0].name) == name &&
        CefString(&cookies[0].value) == value) {
      callback.yes();
    }
  }

  std::string scheme_;
  std::string url1_;
  std::string url2_;
  std::string url3_;

  CefRefPtr<RequestContextHandler> context_handler_;

  CefRefPtr<CefCookieManager> manager1_;
  CefRefPtr<CefCookieManager> manager2_;

  TrackCallback got_process_request1_;
  TrackCallback got_process_request2_;
  TrackCallback got_process_request3_;
  TrackCallback got_create_cookie_;
  TrackCallback got_process_request_cookie_;
  TrackCallback got_cookie_manager1_;
  TrackCallback got_cookie_manager2_;
  TrackCallback got_load_end1_;
  TrackCallback got_load_end2_;
  TrackCallback got_load_end3_;
  TrackCallback got_cookie1_;
  TrackCallback got_cookie2_;
  TrackCallback got_cookie3_;
};

}  // namespace

// Verify use of multiple cookie managers via HTTP.
TEST(CookieTest, GetCookieManagerHttp) {
  CefRefPtr<CookieTestSchemeHandler> handler =
      new CookieTestSchemeHandler("http");
  handler->ExecuteTest();

  EXPECT_TRUE(handler->got_process_request1_);
  EXPECT_TRUE(handler->got_process_request2_);
  EXPECT_TRUE(handler->got_process_request3_);
  EXPECT_FALSE(handler->got_create_cookie_);
  EXPECT_TRUE(handler->got_process_request_cookie_);
  EXPECT_TRUE(handler->got_cookie_manager1_);
  EXPECT_TRUE(handler->got_cookie_manager2_);
  EXPECT_TRUE(handler->got_load_end1_);
  EXPECT_TRUE(handler->got_load_end2_);
  EXPECT_TRUE(handler->got_load_end3_);
  EXPECT_TRUE(handler->got_cookie1_);
  EXPECT_TRUE(handler->got_cookie2_);
  EXPECT_TRUE(handler->got_cookie3_);

  ReleaseAndWaitForDestructor(handler);
}

// Verify use of multiple cookie managers via a custom scheme.
TEST(CookieTest, GetCookieManagerCustom) {
  CefRefPtr<CookieTestSchemeHandler> handler =
      new CookieTestSchemeHandler("ccustom");
  handler->ExecuteTest();

  EXPECT_TRUE(handler->got_process_request1_);
  EXPECT_TRUE(handler->got_process_request2_);
  EXPECT_TRUE(handler->got_process_request3_);
  EXPECT_FALSE(handler->got_create_cookie_);
  EXPECT_TRUE(handler->got_process_request_cookie_);
  EXPECT_TRUE(handler->got_cookie_manager1_);
  EXPECT_TRUE(handler->got_cookie_manager2_);
  EXPECT_TRUE(handler->got_load_end1_);
  EXPECT_TRUE(handler->got_load_end2_);
  EXPECT_TRUE(handler->got_load_end3_);
  EXPECT_TRUE(handler->got_cookie1_);
  EXPECT_TRUE(handler->got_cookie2_);
  EXPECT_TRUE(handler->got_cookie3_);

  ReleaseAndWaitForDestructor(handler);
}

// Entry point for registering custom schemes.
// Called from client_app_delegates.cc.
void RegisterCookieCustomSchemes(
      CefRefPtr<CefSchemeRegistrar> registrar,
      std::vector<CefString>& cookiable_schemes) {
  // Used by GetCookieManagerCustom test.
  registrar->AddCustomScheme("ccustom", true, false, false);
}