client_handler.cpp

// Copyright (c) 2011 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 "client_handler.h"
#include <algorithm>
#include <stdio.h>
#include <sstream>
#include <string>
#include "include/cef_browser.h"
#include "include/cef_frame.h"
#include "include/cef_path_util.h"
#include "include/cef_process_util.h"
#include "include/cef_runnable.h"
#include "include/wrapper/cef_stream_resource_handler.h"
#include "usbtoken.h"
#include "client_renderer.h"
#include "client_switches.h"
#include "resource_util.h"
#include "string_util.h"

#include "inc/token.h"

#include "ep_pkcs11_scheme.h"

#include "inc/util_pkcs15.h"

ClientHandler::ClientHandler()
  : m_MainHwnd(NULL),
    app_running_(false),
    m_BrowserId(0),
    m_StartupURL("pkcs11://epsilon.ma"),
    m_bFocusOnEditableField(false), m_bExternalDevTools(false) {
  CreateProcessMessageDelegates(process_message_delegates_);
  CreateRequestDelegates(request_delegates_);  
}

ClientHandler::~ClientHandler() {

#if defined(WIN32)

	if (m_watcherHnd) {
		TerminateThread(m_watcherHnd, 0);
		//CloseHandle(m_watcherHnd);
		m_watcherHnd = NULL;
	}

#endif

}

bool ClientHandler::OnProcessMessageReceived(
    CefRefPtr<CefBrowser> browser,
    CefProcessId source_process,
    CefRefPtr<CefProcessMessage> message) {

  bool handled = false;

  // Execute delegate callbacks.
  ProcessMessageDelegateSet::iterator it = process_message_delegates_.begin();
  for (; it != process_message_delegates_.end() && !handled; ++it) {
    handled = (*it)->OnProcessMessageReceived(this, browser, source_process,
                                              message);
  }

  return handled;
}

void ClientHandler::OnBeforeContextMenu(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefContextMenuParams> params,
    CefRefPtr<CefMenuModel> model) {
		model->Clear();
  //if ((params->GetTypeFlags() & (CM_TYPEFLAG_PAGE | CM_TYPEFLAG_FRAME)) != 0) {
    // Add a separator if the menu already has items.
    //if (model->GetCount() > 0)
      //model->AddSeparator();

    // Add a "Show DevTools" item to all context menus.
    //model->AddItem(CLIENT_ID_SHOW_DEVTOOLS, "&Show DevTools");

    //CefString devtools_url = browser->GetHost()->GetDevToolsURL(true);
    //if (devtools_url.empty() ||
     //   m_OpenDevToolsURLs.find(devtools_url) != m_OpenDevToolsURLs.end()) {
      // Disable the menu option if DevTools isn't enabled or if a window is
      // already open for the current URL.
      //model->SetEnabled(CLIENT_ID_SHOW_DEVTOOLS, true);
    //}

    // Test context menu features.
    //BuildTestMenu(model);
  //}
}

bool ClientHandler::OnContextMenuCommand(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefContextMenuParams> params,
    int command_id,
    EventFlags event_flags) {
  //switch (command_id) {
    //case CLIENT_ID_SHOW_DEVTOOLS:
      //ShowDevTools(browser);
      //return true;
    //default:  // Allow default handling, if any.
      return false; //ExecuteTestMenu(command_id);
  //}
}
void ClientHandler::OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
                                         bool isLoading,
                                         bool canGoBack,
                                         bool canGoForward) {
  REQUIRE_UI_THREAD();
  SetLoading(isLoading);
}

//bool ClientHandler::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
//                                     const CefString& message,
//                                     const CefString& source,
//                                     int line) {
//  REQUIRE_UI_THREAD();
//
//  bool first_message;
//  std::string logFile;
//
//  {
//    AutoLock lock_scope(this);
//
//    first_message = m_LogFile.empty();
//    if (first_message) {
//      std::stringstream ss;
//      ss << AppGetWorkingDirectory();
//#if defined(OS_WIN)
//      ss << "\\";
//#else
//      ss << "/";
//#endif
//      ss << "console.log";
//      m_LogFile = ss.str();
//    }
//    logFile = m_LogFile;
//  }
//
//  FILE* file = fopen(logFile.c_str(), "a");
//  if (file) {
//    std::stringstream ss;
//    ss << "Message: " << std::string(message) << "\r\nSource: " <<
//        std::string(source) << "\r\nLine: " << line <<
//        "\r\n-----------------------\r\n";
//    fputs(ss.str().c_str(), file);
//    fclose(file);
//
//    //if (first_message)
//      //SendNotification(NOTIFY_CONSOLE_MESSAGE);
//  }
//
//  return false;
//}

void ClientHandler::OnBeforeDownload(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefDownloadItem> download_item,
    const CefString& suggested_name,
    CefRefPtr<CefBeforeDownloadCallback> callback) {
  REQUIRE_UI_THREAD();
  // Continue the download and show the "Save As" dialog.
  callback->Continue(GetDownloadPath(suggested_name), true);
}

void ClientHandler::OnDownloadUpdated(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefDownloadItem> download_item,
    CefRefPtr<CefDownloadItemCallback> callback) {
  REQUIRE_UI_THREAD();
  if (download_item->IsComplete()) {
    SetLastDownloadFile(download_item->GetFullPath());
    SendNotification(NOTIFY_DOWNLOAD_COMPLETE);
  }
}

void ClientHandler::SetLastDownloadFile(const std::string& fileName) {
  AutoLock lock_scope(this);
  m_LastDownloadFile = fileName;
}

std::string ClientHandler::GetLastDownloadFile() {
  AutoLock lock_scope(this);
  return m_LastDownloadFile;
}

//void ClientHandler::OnRequestGeolocationPermission(
//      CefRefPtr<CefBrowser> browser,
//      const CefString& requesting_url,
//      int request_id,
//      CefRefPtr<CefGeolocationCallback> callback) {
//  // Allow geolocation access from all websites.
//  callback->Continue(true);
//}

bool ClientHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
                                  const CefKeyEvent& event,
                                  CefEventHandle os_event,
                                  bool* is_keyboard_shortcut) {
  //ASSERT(m_bFocusOnEditableField == event.focus_on_editable_field);
  //if (!event.focus_on_editable_field && event.windows_key_code == 0x20) {
    // Special handling for the space character when an input element does not
    // have focus. Handling the event in OnPreKeyEvent() keeps the event from
    // being processed in the renderer. If we instead handled the event in the
    // OnKeyEvent() method the space key would cause the window to scroll in
    // addition to showing the alert box.
    //if (event.type == KEYEVENT_RAWKEYDOWN) {
    //  browser->GetMainFrame()->ExecuteJavaScript(
      //    "alert('You pressed the space bar!');", "", 0);
    //}
    //return true;
  //}

  return false;
}

void ClientHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
  REQUIRE_UI_THREAD();

  AutoLock lock_scope(this);
  if (!m_Browser.get())   {
    // We need to keep the main child window, but not popup windows
    m_Browser = browser;
    m_BrowserId = browser->GetIdentifier();
  }
}

bool ClientHandler::DoClose(CefRefPtr<CefBrowser> browser) {
  REQUIRE_UI_THREAD();

  if (m_BrowserId == browser->GetIdentifier()) {
    // Since the main window contains the browser window, we need to close
    // the parent window instead of the browser window.
    CloseMainWindow();

    // Return true here so that we can skip closing the browser window
    // in this pass. (It will be destroyed due to the call to close
    // the parent above.)
    return true;
  }

  // A popup browser window is not contained in another window, so we can let
  // these windows close by themselves.
  return false;
}

void ClientHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
  REQUIRE_UI_THREAD();

  if (m_BrowserId == browser->GetIdentifier()) {
    // Free the browser pointer so that the browser can be destroyed
    m_Browser = NULL;
  } 
  
  else if (browser->IsPopup()) {
    // Remove the record for DevTools popup windows.
    std::set<std::string>::iterator it =
        m_OpenDevToolsURLs.find(browser->GetMainFrame()->GetURL());
    if (it != m_OpenDevToolsURLs.end())
      m_OpenDevToolsURLs.erase(it);
  }
}

void ClientHandler::OnLoadStart(CefRefPtr<CefBrowser> browser,
                                CefRefPtr<CefFrame> frame) {
  REQUIRE_UI_THREAD();

  if (m_BrowserId == browser->GetIdentifier() && frame->IsMain()) {
    // We've just started loading a page
    SetLoading(true);
  }
}

void ClientHandler::OnLoadEnd(CefRefPtr<CefBrowser> browser,
                              CefRefPtr<CefFrame> frame,
                              int httpStatusCode) {
  REQUIRE_UI_THREAD();

  if (m_BrowserId == browser->GetIdentifier() && frame->IsMain()) {
    // We've just finished loading a page
    SetLoading(false);

    // Continue the DOM test.
//    if (frame->GetURL() == dom_test::kTestUrl)
//      dom_test::OnLoadEnd(browser);
  }
}

void ClientHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
                                CefRefPtr<CefFrame> frame,
                                ErrorCode errorCode,
                                const CefString& errorText,
                                const CefString& failedUrl) {
  REQUIRE_UI_THREAD();

  // Don't display an error for downloaded files.
  if (errorCode == ERR_ABORTED)
    return;

  // Don't display an error for external protocols that we allow the OS to
  // handle. See OnProtocolExecution().
  if (errorCode == ERR_UNKNOWN_URL_SCHEME) {
    std::string urlStr = frame->GetURL();
    if (urlStr.find("spotify:") == 0)
      return;
  }

  // Display a load error message.
  std::stringstream ss;
  ss << "<html><body><h2>Failed to load URL " << std::string(failedUrl) <<
        " with error " << std::string(errorText) << " (" << errorCode <<
        ").</h2></body></html>";
  frame->LoadString(ss.str(), failedUrl);
}

void ClientHandler::OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
                                              TerminationStatus status) {
  // Load the startup URL if that's not the website that we terminated on.
  CefRefPtr<CefFrame> frame = browser->GetMainFrame();
  std::string url = frame->GetURL();
  std::transform(url.begin(), url.end(), url.begin(), tolower);

  std::string startupURL = GetStartupURL();
  if (url.find(startupURL) != 0)
    frame->LoadURL(startupURL);
}

CefRefPtr<CefResourceHandler> ClientHandler::GetResourceHandler(
      CefRefPtr<CefBrowser> browser,
      CefRefPtr<CefFrame> frame,
      CefRefPtr<CefRequest> request) {
  
  //std::string url = request->GetURL();
  
  //if (url == "http://tests/request") {
  //  // Show the request contents
  //  std::string dump;
  //  DumpRequestContents(request, dump);
  //  CefRefPtr<CefStreamReader> stream =
  //      CefStreamReader::CreateForData(
  //          static_cast<void*>(const_cast<char*>(dump.c_str())),
  //          dump.size());
  //  ASSERT(stream.get());
  //  return new CefStreamResourceHandler("text/plain", stream);
  //} else if (url == "http://tests/dialogs") {
  //  // Show the dialogs contents
  //  CefRefPtr<CefStreamReader> stream =
  //      GetBinaryResourceReader("dialogs.html");
  //  ASSERT(stream.get());
  //  return new CefStreamResourceHandler("text/html", stream);
  ////} else if (url == dom_test::kTestUrl) {
  ////  // Show the domaccess contents
  //  //CefRefPtr<CefStreamReader> stream =
  //   //  GetBinaryResourceReader("domaccess.html");
  //  //ASSERT(stream.get());
  //  //return new CefStreamResourceHandler("text/html", stream);
  //} else if (url == "http://tests/localstorage") {
  //  // Show the localstorage contents
  //  CefRefPtr<CefStreamReader> stream =
  //      GetBinaryResourceReader("localstorage.html");
  //  ASSERT(stream.get());
  //  return new CefStreamResourceHandler("text/html", stream);
  //} else if (url == "http://tests/xmlhttprequest") {
  //  // Show the xmlhttprequest contents
  //  CefRefPtr<CefStreamReader> stream =
  //     GetBinaryResourceReader("xmlhttprequest.html");
  //  ASSERT(stream.get());
  //  return new CefStreamResourceHandler("text/html", stream);
  //}

  CefRefPtr<CefResourceHandler> handler;

  // Execute delegate callbacks.
  RequestDelegateSet::iterator it = request_delegates_.begin();
  for (; it != request_delegates_.end() && !handler.get(); ++it)
    handler = (*it)->GetResourceHandler(this, browser, frame, request);

  return handler;
}

void ClientHandler::SetMainHwnd(CefWindowHandle hwnd) {
  AutoLock lock_scope(this);
  m_MainHwnd = hwnd;
}

//void ClientHandler::SetEditHwnd(CefWindowHandle hwnd) {
//  AutoLock lock_scope(this);
//  m_EditHwnd = hwnd;
//}

//void ClientHandler::SetButtonHwnds(CefWindowHandle backHwnd,
//                                   CefWindowHandle forwardHwnd,
//                                   CefWindowHandle reloadHwnd,
//                                   CefWindowHandle stopHwnd) {
//  AutoLock lock_scope(this);
//  m_BackHwnd = backHwnd;
//  m_ForwardHwnd = forwardHwnd;
//  m_ReloadHwnd = reloadHwnd;
//  m_StopHwnd = stopHwnd;
//}

std::string ClientHandler::GetLogFile() {
  AutoLock lock_scope(this);
  return m_LogFile;
}

//void ClientHandler::SetLastDownloadFile(const std::string& fileName) {
//  AutoLock lock_scope(this);
//  m_LastDownloadFile = fileName;
//}

//std::string ClientHandler::GetLastDownloadFile() {
//  AutoLock lock_scope(this);
//  return m_LastDownloadFile;
//}

bool ClientHandler::Save(const std::string& path, const std::string& data) {
  FILE* f = fopen(path.c_str(), "w");
  if (!f)
    return false;
  fwrite(data.c_str(), data.size(), 1, f);
  fclose(f);
  return true;
}

void ClientHandler::ShowDevTools(CefRefPtr<CefBrowser> browser) {
  std::string devtools_url = browser->GetHost()->GetDevToolsURL(false);
  if (!devtools_url.empty()) {
    if (m_bExternalDevTools) {
      // Open DevTools in an external browser window.
      LaunchExternalBrowser(devtools_url);
    } else if (m_OpenDevToolsURLs.find(devtools_url) ==
               m_OpenDevToolsURLs.end()) {
      // Open DevTools in a popup window.
      m_OpenDevToolsURLs.insert(devtools_url);
      browser->GetMainFrame()->ExecuteJavaScript(
          "window.open('" +  devtools_url + "');", "about:blank", 0);
    }
  }
}

// static
void ClientHandler::LaunchExternalBrowser(const std::string& url) {
  if (CefCurrentlyOn(TID_PROCESS_LAUNCHER)) {
    // Retrieve the current executable path.
    CefString file_exe;
    if (!CefGetPath(PK_FILE_EXE, file_exe))
      return;

    // Create the command line.
    CefRefPtr<CefCommandLine> command_line =
        CefCommandLine::CreateCommandLine();
    command_line->SetProgram(file_exe);
    command_line->AppendSwitchWithValue(usbtoken::kUrl, url);

    // Launch the process.
    CefLaunchProcess(command_line);
  } else {
    // Execute on the PROCESS_LAUNCHER thread.
    CefPostTask(TID_PROCESS_LAUNCHER,
        NewCefRunnableFunction(&ClientHandler::LaunchExternalBrowser, url));
  }
}


// static
void ClientHandler::CreateProcessMessageDelegates(
      ProcessMessageDelegateSet& delegates) {
  epsilon::CreateProcessMessageDelegates(delegates);
}

// static
void ClientHandler::CreateRequestDelegates(RequestDelegateSet& delegates) {
}

//void ClientHandler::BuildTestMenu(CefRefPtr<CefMenuModel> model) {
//  if (model->GetCount() > 0)
//    model->AddSeparator();
//
//  // Build the sub menu.
//  CefRefPtr<CefMenuModel> submenu =
//      model->AddSubMenu(CLIENT_ID_TESTMENU_SUBMENU, "Context Menu Test");
//  submenu->AddCheckItem(CLIENT_ID_TESTMENU_CHECKITEM, "Check Item");
//  submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM1, "Radio Item 1", 0);
//  submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM2, "Radio Item 2", 0);
//  submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM3, "Radio Item 3", 0);
//
//  // Check the check item.
//  if (m_TestMenuState.check_item)
//    submenu->SetChecked(CLIENT_ID_TESTMENU_CHECKITEM, true);
//
//  // Check the selected radio item.
//  submenu->SetChecked(
//      CLIENT_ID_TESTMENU_RADIOITEM1 + m_TestMenuState.radio_item, true);
//}

//bool ClientHandler::ExecuteTestMenu(int command_id) {
//  if (command_id == CLIENT_ID_TESTMENU_CHECKITEM) {
//    // Toggle the check item.
//    m_TestMenuState.check_item ^= 1;
//    return true;
//  } else if (command_id >= CLIENT_ID_TESTMENU_RADIOITEM1 &&
//             command_id <= CLIENT_ID_TESTMENU_RADIOITEM3) {
//    // Store the selected radio item.
//    m_TestMenuState.radio_item = (command_id - CLIENT_ID_TESTMENU_RADIOITEM1);
//    return true;
//  }
//
//  // Allow default handling to proceed.
//  return false;
//}