pulsar/native/atom_cef_client.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 <sstream>
#include <iostream>
#include "include/cef_path_util.h"
#include "include/cef_process_util.h"
#include "include/cef_runnable.h"
#include "native/atom_cef_client.h"
#include "cef_v8.h"

AtomCefClient::AtomCefClient(){

}

AtomCefClient::~AtomCefClient() {
}


bool AtomCefClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
                                             CefProcessId source_process,
                                             CefRefPtr<CefProcessMessage> message) {
  std::string name = message->GetName().ToString();
  CefRefPtr<CefListValue> argumentList = message->GetArgumentList();  
  int messageId = argumentList->GetInt(0);

  
  if (name == "open") {
    bool hasArguments = message->GetArgumentList()->GetSize() > 1;
    hasArguments ? Open(message->GetArgumentList()->GetString(1)) : Open();
    return true;
  }
  if (name == "newWindow") {
    NewWindow();
    return true;
  }


  return false;
}


void AtomCefClient::OnBeforeContextMenu(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefContextMenuParams> params,
    CefRefPtr<CefMenuModel> model) {

  model->Clear();
  model->AddItem(MENU_ID_USER_FIRST, "&Show DevTools");
}

bool AtomCefClient::OnContextMenuCommand(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefContextMenuParams> params,
    int command_id,
    EventFlags event_flags) {

  if (command_id == MENU_ID_USER_FIRST) {
    ShowDevTools(browser);
    return true;
  }
  else {
    return false;
  }
}

bool AtomCefClient::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
                                     const CefString& message,
                                     const CefString& source,
                                     int line) {
  REQUIRE_UI_THREAD();
  std::cout << std::string(message) << "\n";
  return true;
}


bool AtomCefClient::OnKeyEvent(CefRefPtr<CefBrowser> browser,
                               const CefKeyEvent& event,
                               CefEventHandle os_event) {
  if (event.modifiers == KEY_META && event.character == 'r') {
    browser->SendProcessMessage(PID_RENDERER, CefProcessMessage::Create("reload"));
  }
}

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


  // this was in cefclient... was there a good reason?
//  if(m_BrowserHwnd == browser->GetWindowHandle()) {
//    // Free the browser pointer so that the browser can be destroyed
//    m_Browser = NULL;
//  }

  m_Browser = NULL;
}

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

  AutoLock lock_scope(this);
  if (!m_Browser.get())   {
    m_Browser = browser;
  }

  GetBrowser()->GetHost()->SetFocus(true);
}

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

  if (errorCode == ERR_ABORTED) { // Don't display an error for downloaded files.
    return;
  }
  else if (errorCode == ERR_UNKNOWN_URL_SCHEME) { // Don't display an error for external protocols that we allow the OS to handle. See OnProtocolExecution().
    return;
  }
  else {
    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 AtomCefClient::ShowDevTools(CefRefPtr<CefBrowser> browser) {
  std::string devtools_url = browser->GetHost()->GetDevToolsURL(true);
  if (!devtools_url.empty()) {
    browser->GetMainFrame()->ExecuteJavaScript("window.open('" +  devtools_url + "');", "about:blank", 0);
  }
}
Initial commit 2012-08-10 23:32:19 +04:00			`// 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 <sstream>`
Atom is getting closer... 2012-08-22 04:22:43 +04:00			`#include <iostream>`
Initial commit 2012-08-10 23:32:19 +04:00			`#include "include/cef_path_util.h"`
			`#include "include/cef_process_util.h"`
			`#include "include/cef_runnable.h"`
Rename atom folder to native 2012-08-28 00:21:59 +04:00			`#include "native/atom_cef_client.h"`
WIP: sending reload message to render process on meta-r 2012-08-28 03:39:12 +04:00			`#include "cef_v8.h"`
Initial commit 2012-08-10 23:32:19 +04:00
Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`AtomCefClient::AtomCefClient(){`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`AtomCefClient::~AtomCefClient() {`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Add `atom` extension, which implements `atom.open` We send a message from the render process to the browser process indicating which path to open. Also start introducing a `v8_extensions::` namespace to contain the extensions. 2012-08-28 20:08:50 +04:00
			`bool AtomCefClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,`
			`CefProcessId source_process,`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`CefRefPtr<CefProcessMessage> message) {`
Add `atom` extension, which implements `atom.open` We send a message from the render process to the browser process indicating which path to open. Also start introducing a `v8_extensions::` namespace to contain the extensions. 2012-08-28 20:08:50 +04:00			`std::string name = message->GetName().ToString();`
WIP: pushing message id to front of message data so browser process can reply 2012-08-29 02:20:49 +04:00			`CefRefPtr<CefListValue> argumentList = message->GetArgumentList();`
			`int messageId = argumentList->GetInt(0);`
Skipping the first element of the message argument list because its a message id 2012-08-30 00:33:36 +04:00
WIP: pushing message id to front of message data so browser process can reply 2012-08-29 02:20:49 +04:00
Add `atom` extension, which implements `atom.open` We send a message from the render process to the browser process indicating which path to open. Also start introducing a `v8_extensions::` namespace to contain the extensions. 2012-08-28 20:08:50 +04:00			`if (name == "open") {`
Skipping the first element of the message argument list because its a message id 2012-08-30 00:33:36 +04:00			`bool hasArguments = message->GetArgumentList()->GetSize() > 1;`
			`hasArguments ? Open(message->GetArgumentList()->GetString(1)) : Open();`
:lipstick: 2012-08-29 22:36:52 +04:00			`return true;`
Make meta-n (new window) work 2012-08-29 04:04:56 +04:00			`}`
			`if (name == "newWindow") {`
			`NewWindow();`
Add `atom` extension, which implements `atom.open` We send a message from the render process to the browser process indicating which path to open. Also start introducing a `v8_extensions::` namespace to contain the extensions. 2012-08-28 20:08:50 +04:00			`return true;`
			`}`
:lipstick: 2012-08-29 01:05:00 +04:00
Make meta-n (new window) work 2012-08-29 04:04:56 +04:00
Add `atom` extension, which implements `atom.open` We send a message from the render process to the browser process indicating which path to open. Also start introducing a `v8_extensions::` namespace to contain the extensions. 2012-08-28 20:08:50 +04:00			`return false;`
			`}`


Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`void AtomCefClient::OnBeforeContextMenu(`
Initial commit 2012-08-10 23:32:19 +04:00			`CefRefPtr<CefBrowser> browser,`
			`CefRefPtr<CefFrame> frame,`
			`CefRefPtr<CefContextMenuParams> params,`
			`CefRefPtr<CefMenuModel> model) {`

Remove all default context menu items 2012-08-29 23:27:24 +04:00			`model->Clear();`
Flushing things we don't need 2012-08-21 01:09:57 +04:00			`model->AddItem(MENU_ID_USER_FIRST, "&Show DevTools");`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`bool AtomCefClient::OnContextMenuCommand(`
Initial commit 2012-08-10 23:32:19 +04:00			`CefRefPtr<CefBrowser> browser,`
			`CefRefPtr<CefFrame> frame,`
			`CefRefPtr<CefContextMenuParams> params,`
			`int command_id,`
			`EventFlags event_flags) {`
Flushing things we don't need 2012-08-21 01:09:57 +04:00
			`if (command_id == MENU_ID_USER_FIRST) {`
trying to get devtools to work 2012-08-23 02:29:39 +04:00			`ShowDevTools(browser);`
Flushing things we don't need 2012-08-21 01:09:57 +04:00			`return true;`
			`}`
			`else {`
			`return false;`
Initial commit 2012-08-10 23:32:19 +04:00			`}`
			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`bool AtomCefClient::OnConsoleMessage(CefRefPtr<CefBrowser> browser,`
Initial commit 2012-08-10 23:32:19 +04:00			`const CefString& message,`
			`const CefString& source,`
			`int line) {`
			`REQUIRE_UI_THREAD();`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`std::cout << std::string(message) << "\n";`
Atom is getting closer... 2012-08-22 04:22:43 +04:00			`return true;`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

WIP: sending reload message to render process on meta-r 2012-08-28 03:39:12 +04:00
			`bool AtomCefClient::OnKeyEvent(CefRefPtr<CefBrowser> browser,`
			`const CefKeyEvent& event,`
			`CefEventHandle os_event) {`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`if (event.modifiers == KEY_META && event.character == 'r') {`
WIP: sending reload message to render process on meta-r 2012-08-28 03:39:12 +04:00			`browser->SendProcessMessage(PID_RENDERER, CefProcessMessage::Create("reload"));`
			`}`
			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`void AtomCefClient::OnBeforeClose(CefRefPtr<CefBrowser> browser) {`
Initial commit 2012-08-10 23:32:19 +04:00			`REQUIRE_UI_THREAD();`
Null out the browser reference in ClientHandler-OnBeforeClose 2012-08-25 03:48:27 +04:00
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00
Null out the browser reference in ClientHandler-OnBeforeClose 2012-08-25 03:48:27 +04:00			`// this was in cefclient... was there a good reason?`
			`// if(m_BrowserHwnd == browser->GetWindowHandle()) {`
			`// // Free the browser pointer so that the browser can be destroyed`
			`// m_Browser = NULL;`
			`// }`
WIP: Handling reload, but need to put js dialog handler in proper place 2012-08-28 04:10:28 +04:00
Null out the browser reference in ClientHandler-OnBeforeClose 2012-08-25 03:48:27 +04:00			`m_Browser = NULL;`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`void AtomCefClient::OnAfterCreated(CefRefPtr<CefBrowser> browser) {`
Initial commit 2012-08-10 23:32:19 +04:00			`REQUIRE_UI_THREAD();`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00
Atom is getting closer... 2012-08-22 04:22:43 +04:00			`AutoLock lock_scope(this);`
			`if (!m_Browser.get()) {`
			`m_Browser = browser;`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`}`
Focus windows when they are opened 2012-08-29 01:04:44 +04:00
			`GetBrowser()->GetHost()->SetFocus(true);`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`void AtomCefClient::OnLoadError(CefRefPtr<CefBrowser> browser,`
Initial commit 2012-08-10 23:32:19 +04:00			`CefRefPtr<CefFrame> frame,`
			`ErrorCode errorCode,`
			`const CefString& errorText,`
			`const CefString& failedUrl) {`
			`REQUIRE_UI_THREAD();`

Atom is getting closer... 2012-08-22 04:22:43 +04:00			`if (errorCode == ERR_ABORTED) { // Don't display an error for downloaded files.`
Flushing things we don't need 2012-08-21 01:09:57 +04:00			`return;`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`}`
Flushing things we don't need 2012-08-21 01:09:57 +04:00			`else if (errorCode == ERR_UNKNOWN_URL_SCHEME) { // Don't display an error for external protocols that we allow the OS to handle. See OnProtocolExecution().`
Initial commit 2012-08-10 23:32:19 +04:00			`return;`
			`}`
Whitespace :lipstick: 2012-08-28 20:58:24 +04:00			`else {`
Flushing things we don't need 2012-08-21 01:09:57 +04:00			`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);`
			`}`
Initial commit 2012-08-10 23:32:19 +04:00			`}`

Rename ClientHandler to AtomCefClient This clarifies its role relative to the Cef API… that it is Atom's version of the CefClient. 2012-08-25 21:17:47 +04:00			`void AtomCefClient::ShowDevTools(CefRefPtr<CefBrowser> browser) {`
Dev tools working 2012-08-23 23:38:52 +04:00			`std::string devtools_url = browser->GetHost()->GetDevToolsURL(true);`
Initial commit 2012-08-10 23:32:19 +04:00			`if (!devtools_url.empty()) {`
trying to get devtools to work 2012-08-23 02:29:39 +04:00			`browser->GetMainFrame()->ExecuteJavaScript("window.open('" + devtools_url + "');", "about:blank", 0);`
Initial commit 2012-08-10 23:32:19 +04:00			`}`
			`}`