/* Copyright (C) 2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include <core.h>

#include <stdlib.h>

#include "libbrowser_cef.h"

#include <include/cef_app.h>

#include <list>

#include <set>

#if defined(TARGET_PLATFORM_POSIX)

#include "signal_restore_posix.h"

#include <sys/time.h>

#endif

////////////////////////////////////////////////////////////////////////////////

#define CEF_DUMMY_URL "http://libbrowser_dummy_url/"

////////////////////////////////////////////////////////////////////////////////

// String conversion

bool MCCefStringToUtf8String(const CefString &p_cef_string, char *&r_u8_string)

{

if (p_cef_string.empty())

return MCCStringClone("", r_u8_string);

return MCCStringFromUnicode(p_cef_string.c_str(), r_u8_string);

}

bool MCCefStringFromUtf8String(const char *p_u8_string, cef_string_t *r_cef_string)

{

return 0 != cef_string_from_utf8(p_u8_string, MCCStringLength(p_u8_string), r_cef_string);

}

bool MCCefStringFromUtf8String(const char *p_u8_string, CefString &r_cef_string)

{

return MCCefStringFromUtf8String(p_u8_string, r_cef_string.GetWritableStruct());

}

bool MCCefStringToUInt(const CefString &p_string, uint32_t &r_int)

{

char_t * t_tmp_string;

t_tmp_string = nil;

uint32_t t_int;

bool t_success;

t_success = MCCefStringToUtf8String(p_string, t_tmp_string);

if (t_success)

{

char *t_end;

t_int = strtoul(t_tmp_string, &t_end, 10);

t_success = t_end == t_tmp_string + MCCStringLength(t_tmp_string);

}

if (t_tmp_string != nil)

MCCStringFree(t_tmp_string);

if (t_success)

r_int = t_int;

return t_success;

}

////////////////////////////////////////////////////////////////////////////////

bool MCCefListToBrowserList(CefRefPtr<CefListValue> p_list, MCBrowserListRef &r_list)

{

bool t_success;

t_success = true;

MCBrowserListRef t_list;

t_list = nil;

size_t t_size;

t_size = p_list->GetSize();

if (t_success)

t_success = MCBrowserListCreate(t_list, t_size);

for (uint32_t i = 0; t_success && i < t_size; i++)

{

switch (p_list->GetType(i))

{

case VTYPE_BOOL:

t_success = MCBrowserListSetBoolean(t_list, i, p_list->GetBool(i));

break;

case VTYPE_INT:

t_success = MCBrowserListSetInteger(t_list, i, p_list->GetInt(i));

break;

case VTYPE_DOUBLE:

t_success = MCBrowserListSetDouble(t_list, i, p_list->GetDouble(i));

break;

case VTYPE_STRING:

{

char *t_string = nil;

t_success = MCCefStringToUtf8String(p_list->GetString(i), t_string) && MCBrowserListSetUTF8String(t_list, i, t_string);

if (t_string != nil)

MCCStringFree(t_string);

break;

}

case VTYPE_LIST:

{

MCBrowserListRef t_list_val = nil;

t_success = MCCefListToBrowserList(p_list->GetList(i), t_list_val) && MCBrowserListSetList(t_list, i, t_list_val);

MCBrowserListRelease(t_list_val);

break;

}

case VTYPE_DICTIONARY:

{

MCBrowserDictionaryRef t_dict_val = nil;

t_success = MCCefDictionaryToBrowserDictionary(p_list->GetDictionary(i), t_dict_val) && MCBrowserListSetDictionary(t_list, i, t_dict_val);

MCBrowserDictionaryRelease(t_dict_val);

break;

}

default:

// unimplemented value type

t_success = false;

}

}

if (t_success)

r_list = t_list;

else

MCBrowserListRelease(t_list);

return t_success;

}

bool MCCefDictionaryToBrowserDictionary(CefRefPtr<CefDictionaryValue> p_dict, MCBrowserDictionaryRef &r_dict)

{

bool t_success;

t_success = true;

MCBrowserDictionaryRef t_dict;

t_dict = nil;

CefDictionaryValue::KeyList t_key_list;

if (t_success)

t_success = p_dict->GetKeys(t_key_list);

if (t_success)

t_success = MCBrowserDictionaryCreate(t_dict, t_key_list.size());

for (CefDictionaryValue::KeyList::iterator i = t_key_list.begin(); t_success && i < t_key_list.end(); i++)

{

char *t_key;

t_key = nil;

if (t_success)

t_success = MCCefStringToUtf8String(*i, t_key);

if (t_success)

{

switch (p_dict->GetType(*i))

{

case VTYPE_BOOL:

t_success = MCBrowserDictionarySetBoolean(t_dict, t_key, p_dict->GetBool(*i));

break;

case VTYPE_INT:

t_success = MCBrowserDictionarySetInteger(t_dict, t_key, p_dict->GetInt(*i));

break;

case VTYPE_DOUBLE:

t_success = MCBrowserDictionarySetDouble(t_dict, t_key, p_dict->GetDouble(*i));

break;

case VTYPE_STRING:

{

char *t_string = nil;

t_success = MCCefStringToUtf8String(p_dict->GetString(*i), t_string) && MCBrowserDictionarySetUTF8String(t_dict, t_key, t_string);

if (t_string != nil)

MCCStringFree(t_string);

break;

}

case VTYPE_LIST:

{

MCBrowserListRef t_list_val = nil;

t_success = MCCefListToBrowserList(p_dict->GetList(*i), t_list_val) && MCBrowserDictionarySetList(t_dict, t_key, t_list_val);

MCBrowserListRelease(t_list_val);

break;

}

case VTYPE_DICTIONARY:

{

MCBrowserDictionaryRef t_dict_val = nil;

t_success = MCCefDictionaryToBrowserDictionary(p_dict->GetDictionary(*i), t_dict_val) && MCBrowserDictionarySetDictionary(t_dict, t_key, t_dict_val);

MCBrowserDictionaryRelease(t_dict_val);

break;

}

default:

// unimplemented value type

t_success = false;

}

}

if (t_key != nil)

MCCStringFree(t_key);

}

if (t_success)

r_dict = t_dict;

else

MCBrowserDictionaryRelease(t_dict);

return t_success;

}

////////////////////////////////////////////////////////////////////////////////

static const char *s_auth_scheme_strings[] =

{

"basic",

"digest",

"ntlm",

"negotiate",

"spdyproxy",

nil

};

bool MCCefAuthSchemeFromCefString(const CefString &p_string, MCCefAuthScheme &r_scheme)

{

const char **t_strings;

t_strings = s_auth_scheme_strings;

for (uint32_t i = 0; s_auth_scheme_strings[i] != nil; i++)

{

if (p_string == s_auth_scheme_strings[i])

{

r_scheme = (MCCefAuthScheme)i;

return true;

}

}

return false;

}

////////////////////////////////////////////////////////////////////////////////

// Cef initialization / shutdown handling

static bool s_cef_initialised = false;

static bool s_cefbrowser_initialised = false;

static uint32_t s_instance_count = 0;

void MCCefBrowserExternalInit(void)

{

// set up static vars

s_cef_initialised = false;

s_cefbrowser_initialised = false;

s_instance_count = 0;

}

void MCCefBrowserRunloopAction(void *p_context)

{

CefDoMessageLoopWork();

}

class MCCefBrowserApp : public CefApp, CefBrowserProcessHandler

{

public:

virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() OVERRIDE { return this; }

virtual void OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> p_command_line) OVERRIDE

{

if (MCCefPlatformGetHiDPIEnabled())

p_command_line->AppendSwitch(MC_CEF_HIDPI_SWITCH);

}

IMPLEMENT_REFCOUNTING(MCCefBrowserApp)

};

extern "C" int initialise_weak_link_cef(void);

extern "C" int initialise_weak_link_cef_with_path(const char *p_path);

// IM-2014-03-13: [[ revBrowserCEF ]] Initialisation of the CEF library

bool MCCefInitialise(void)

{

if (s_cef_initialised)

return true;

CefMainArgs t_args;

CefSettings t_settings;

t_settings.multi_threaded_message_loop = MC_CEF_USE_MULTITHREADED_MESSAGELOOP;

t_settings.command_line_args_disabled = true;

t_settings.no_sandbox = true;

t_settings.log_severity = LOGSEVERITY_DISABLE;

bool t_success;

t_success = MCCefStringFromUtf8String(MCCefPlatformGetSubProcessName(), &t_settings.browser_subprocess_path);

if (t_success)

{

// IM-2014-03-25: [[ revBrowserCEF ]] Allow per-platform locale path settings

const char *t_locale_path, *t_resource_path;

t_locale_path = MCCefPlatformGetLocalePath();

t_resource_path = MCCefPlatformGetResourcesDirPath();

if (t_locale_path != nil)

t_success = MCCefStringFromUtf8String(t_locale_path, &t_settings.locales_dir_path);

if (t_resource_path != nil)

t_success = MCCefStringFromUtf8String(t_resource_path, &t_settings.resources_dir_path);

}

CefRefPtr<CefApp> t_app = new MCCefBrowserApp();

if (t_success)

t_success = -1 == CefExecuteProcess(t_args, t_app, nil);

if (t_success)

{

#if defined(TARGET_PLATFORM_POSIX)

struct itimerval t_old_timer, t_new_timer;

memset(&t_new_timer, 0, sizeof(t_new_timer));

setitimer(ITIMER_REAL, &t_new_timer, &t_old_timer);

BackupSignalHandlers();

#endif

t_success = CefInitialize(t_args, t_settings, t_app, nil);

#if defined(TARGET_PLATFORM_POSIX)

RestoreSignalHandlers();

setitimer(ITIMER_REAL, &t_old_timer, nil);

#endif

}

s_cef_initialised = t_success;

return s_cef_initialised;

}

// IM-2014-03-13: [[ revBrowserCEF ]] Initialise CEF & install the runloop action

bool MCCefBrowserInitialise(void)

{

if (s_cefbrowser_initialised)

return true;

bool t_success;

t_success = true;

// IM-2014-03-18: [[ revBrowserCEF ]] Initialise dynamically loaded cef library

if (t_success)

{

const char *t_lib_path;

t_lib_path = MCCefPlatformGetCefLibraryPath();

// IM-2014-03-25: [[ revBrowserCEF ]] Look for libcef in platform-defined location

if (t_lib_path != nil)

t_success = initialise_weak_link_cef_with_path(t_lib_path);

else

t_success = initialise_weak_link_cef();

}

if (t_success)

t_success = MCCefInitialise();

if (t_success && !MC_CEF_USE_MULTITHREADED_MESSAGELOOP)

t_success = MCBrowserAddRunloopAction(MCCefBrowserRunloopAction, nil);

s_cefbrowser_initialised = t_success;

return s_cefbrowser_initialised;

}

// IM-2014-03-13: [[ revBrowserCEF ]] Shutdown the CEF library

void MCCefFinalise(void)

{

if (!s_cef_initialised)

return;

CefShutdown();

s_cef_initialised = false;

}

// IM-2014-03-13: [[ revBrowserCEF ]] Shut down the browser

void MCCefBrowserFinalise(void)

{

if (!s_cefbrowser_initialised)

return;

if (!MC_CEF_USE_MULTITHREADED_MESSAGELOOP)

MCBrowserRemoveRunloopAction(MCCefBrowserRunloopAction, nil);

s_cefbrowser_initialised = false;

}

void MCCefIncrementInstanceCount(void)

{

if (s_instance_count == 0)

/* UNCHECKED */ MCCefBrowserInitialise();

s_instance_count++;

}

void MCCefDecrementInstanceCount(void)

{

if (s_instance_count == 0)

return;

s_instance_count--;

if (s_instance_count == 0)

MCCefBrowserFinalise();

}

////////////////////////////////////////////////////////////////////////////////

// Utility class to hold a response from a request to the render process

class MCCefMessageResult

{

private:

bool m_have_result;

bool m_success;

CefValueType m_result_type;

CefString m_result_string;

int m_result_int;

public:

void SetResult(bool p_success, const CefString &p_result)

{

if (HaveResult())

Clear();

m_success = p_success;

m_result_string = p_result;

m_result_type = VTYPE_STRING;

m_have_result = true;

}

void SetResult(bool p_success, int p_result)

{

if (HaveResult())

Clear();

m_success = p_success;

m_result_int = p_result;

m_result_type = VTYPE_INT;

m_have_result = true;

}

bool HaveResult() { return m_have_result; }

bool GetResult(CefString &r_result) const

{

if (!m_success)

return false;

if (m_result_type == VTYPE_STRING)

{

r_result = m_result_string;

return true;

}

// convert to string

bool t_converted;

t_converted = false;

switch (m_result_type)

{

case VTYPE_INT:

{

char *t_tmp;

t_tmp = nil;

t_converted = MCCStringFormat(t_tmp, "%d", m_result_int) &&

MCCefStringFromUtf8String(t_tmp, r_result);

if (t_tmp != nil)

MCCStringFree(t_tmp);

}

break;

}

return t_converted;

}

bool GetResult(int &r_result) const

{

if (!m_success)

return false;

if (m_result_type == VTYPE_INT)

{

r_result = m_result_int;

return true;

}

// convert to int

return false;

}

void Clear()

{

m_have_result = false;

m_result_string.ClearAndFree();

}

};

////////////////////////////////////////////////////////////////////////////////

// Browser client - receives callback messages from the browser

struct MCCefErrorInfo

{

CefString url;

CefString error_message;

CefLoadHandler::ErrorCode error_code;

};

class MCCefBrowserClient : public CefClient, CefLifeSpanHandler, CefRequestHandler, /* CefDownloadHandler ,*/ CefLoadHandler, CefContextMenuHandler, CefDragHandler

{

private:

int m_browser_id;

MCCefBrowserBase *m_owner;

MCCefMessageResult m_message_result;

std::map<int64_t, MCCefErrorInfo> m_load_error_frames;

// IM-2014-05-06: [[ Bug 12384 ]] Set of URLs for which callback messages will not be sent

std::set<CefString> m_ignore_urls;

CefString m_last_request_url;

// Error handling - we need to keep track of url that failed to load in a

// frame so we can send the correct url in onLoadEnd()

void AddLoadErrorFrame(int64_t p_id, const CefString &p_url, const CefString &p_error_msg, CefLoadHandler::ErrorCode p_error_code)

{

m_load_error_frames[p_id].url = p_url;

m_load_error_frames[p_id].error_message = p_error_msg;

m_load_error_frames[p_id].error_code = p_error_code;

}

bool FindLoadErrorFrame(int64_t p_id, MCCefErrorInfo &r_info, bool p_delete)

{

std::map<int64_t, MCCefErrorInfo>::iterator t_iter;

t_iter = m_load_error_frames.find(p_id);

if (t_iter == m_load_error_frames.end())

return false;

r_info = t_iter->second;

if (p_delete)

m_load_error_frames.erase(t_iter);

return true;

}

bool RemoveLoadErrorFrame(int64_t p_id, CefString &r_error_url, CefString &r_error_msg, CefLoadHandler::ErrorCode &r_error_code)

{

MCCefErrorInfo t_info;

if (!FindLoadErrorFrame(p_id, t_info, true))

return false;

r_error_url = t_info.url;

r_error_msg = t_info.error_message;

r_error_code = t_info.error_code;

return true;

}

bool FetchLoadErrorFrame(int64_t p_id, CefString &r_error_url, CefString &r_error_msg, CefLoadHandler::ErrorCode &r_error_code)

{

MCCefErrorInfo t_info;

if (!FindLoadErrorFrame(p_id, t_info, false))

return false;

r_error_url = t_info.url;

r_error_msg = t_info.error_message;

r_error_code = t_info.error_code;

return true;

}

public:

MCCefBrowserClient(MCCefBrowserBase *p_owner)

{

m_owner = p_owner;

m_browser_id = 0;

}

// IM-2014-07-21: [[ Bug 12296 ]] Method to allow owner to notify client of its deletion

void OnOwnerClosed(void)

{

m_owner = nil;

}

// Tell browser which callback interfaces we implement

virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE { return this; }

virtual CefRefPtr<CefRequestHandler> GetRequestHandler() OVERRIDE { return this; }

// virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() OVERRIDE { return this; }

virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE { return this; }

virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() OVERRIDE { return this; }

virtual CefRefPtr<CefDragHandler> GetDragHandler() OVERRIDE { return this; }

void AddIgnoreUrl(const CefString &p_url)

{

m_ignore_urls.insert(p_url);

}

void RemoveIgnoreUrl(const CefString &p_url)

{

m_ignore_urls.erase(p_url);

}

// IM-2014-05-06: [[ Bug 12384 ]] Test if callback should be sent for URL

bool IgnoreUrl(const CefString &p_url)

{

std::set<CefString>::iterator t_iter;

t_iter = m_ignore_urls.find(p_url);

return t_iter != m_ignore_urls.end();

}

MCCefMessageResult &GetMessageResult()

{

return m_message_result;

}

virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> p_browser, CefProcessId p_source_process, CefRefPtr<CefProcessMessage> p_message) OVERRIDE

{

CefString t_message_name;

t_message_name = p_message->GetName();

if (t_message_name == MC_CEFMSG_RESULT)

{

// When we get a result message, the result is stored in the message result object

CefRefPtr<CefListValue> t_args;

t_args = p_message->GetArgumentList();

switch (t_args->GetType(1))

{

case VTYPE_STRING:

m_message_result.SetResult(t_args->GetBool(0), t_args->GetString(1));

break;

case VTYPE_INT:

m_message_result.SetResult(t_args->GetBool(0), t_args->GetInt(1));

break;

default:

MCAssert(false);

}

MCBrowserRunloopBreakWait();

return true;

}

else if (t_message_name == MC_CEFMSG_JS_HANDLER)

{

// Handle JavaScript call to LiveCode handler

CefRefPtr<CefListValue> t_args;

t_args = p_message->GetArgumentList();

char *t_handler;

t_handler = nil;

bool t_success;

t_success = true;

// IM-2014-07-21: [[ Bug 12296 ]] Don't proceed with callback if browser has been closed

if (t_success)

t_success = nil != m_owner;

if (t_success)

t_success = MCCefStringToUtf8String(t_args->GetString(0), t_handler);

uint32_t t_arg_count;

t_arg_count = 0;

MCBrowserListRef t_param_list;

t_param_list = nil;

if (t_success)

t_success = MCCefListToBrowserList(t_args->GetList(1), t_param_list);

if (t_success)

m_owner->OnJavaScriptCall(t_handler, t_param_list);

if (t_handler)

MCCStringFree(t_handler);

if (t_param_list != nil)

MCBrowserListRelease(t_param_list);

return true;

}

return CefClient::OnProcessMessageReceived(p_browser, p_source_process, p_message);

}

// CefLifeSpanHandler interface

// Called on UI thread

virtual void OnAfterCreated(CefRefPtr<CefBrowser> p_browser) OVERRIDE

{

// Keep track of first created browser instance. Any others belong to pop-ups

if (m_browser_id == 0)

{

m_browser_id = p_browser->GetIdentifier();

// IM-2014-07-21: [[ Bug 12296 ]] Check owner has not been closed before invoking callback

if (m_owner != nil)

m_owner->OnCefBrowserCreated(p_browser);

}

MCCefIncrementInstanceCount();

}

virtual bool DoClose(CefRefPtr<CefBrowser> p_browser) OVERRIDE

{

// We handle browser closing here to stop CEF sending WM_CLOSE to the stack window

if (p_browser->GetIdentifier() == m_browser_id)

{

// Close the browser window

if (m_owner != nil)

m_owner->PlatformCloseBrowserWindow(p_browser);

// return true to prevent default handling

return true;

}

return CefLifeSpanHandler::DoClose(p_browser);

}

virtual void OnBeforeClose(CefRefPtr<CefBrowser> p_browser) OVERRIDE

{

if (m_owner != nil)

m_owner->OnCefBrowserClosed(p_browser);

MCCefDecrementInstanceCount();

}

virtual bool OnBeforePopup(

CefRefPtr<CefBrowser> p_browser,

CefRefPtr<CefFrame> p_frame,

const CefString& p_target_url,

const CefString& p_target_frame_name,

CefLifeSpanHandler::WindowOpenDisposition p_target_disposition,

bool p_user_gesture,

const CefPopupFeatures& p_popup_features,

CefWindowInfo& p_window_info,

CefRefPtr<CefClient>& p_client,

CefBrowserSettings& p_settings,

bool* p_no_javascript_access ) OVERRIDE

{

// returning true here will prevent popup windows from opening

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return true;

return !m_owner->GetAllowNewWindow();

}

// CefDragHandler interface

// Called on UI thread

virtual bool OnDragEnter(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefDragData> p_drag_data, CefDragHandler::DragOperationsMask p_mask)

{

// cancel the drag event

return true;

}

// CefRequestHandler interface

// Called on UI thread

virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, CefRefPtr<CefRequest> p_request, bool p_is_redirect) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return true;

bool t_cancel;

t_cancel = false;

CefString t_url;

t_url = p_request->GetURL();

if (IgnoreUrl(t_url))

return false;

char *t_url_str;

t_url_str = nil;

/* UNCHECKED */ MCCefStringToUtf8String(t_url, t_url_str);

if (t_url_str != nil)

MCCStringFree(t_url_str);

return t_cancel;

}

virtual CefRequestHandler::ReturnValue OnBeforeResourceLoad(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, CefRefPtr<CefRequest> p_request, CefRefPtr<CefRequestCallback> p_callback) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return RV_CANCEL;

CefString t_url;

t_url = p_request->GetURL();

if (IgnoreUrl(t_url))

return RV_CONTINUE;

m_last_request_url = t_url;

CefString t_user_agent;

if (!m_owner->GetUserAgent(t_user_agent))

return RV_CONTINUE;

// modify request headers to set user agent

CefRequest::HeaderMap t_headers;

p_request->GetHeaderMap(t_headers);

CefString t_key = "User-Agent";

// clear any current value

t_headers.erase(t_key);

// add new value

t_headers.insert(std::pair<CefString, CefString>(t_key, t_user_agent));

p_request->SetHeaderMap(t_headers);

return RV_CONTINUE;

}

// IM-2014-04-28: [[ CefBrowser ]] Use platform-specific method to get credentials when requested

virtual bool GetAuthCredentials( CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, bool p_is_proxy, const CefString &p_host, int p_port, const CefString &p_realm, const CefString &p_method, CefRefPtr<CefAuthCallback> p_callback) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return true;

bool t_success;

t_success = true;

CefString t_user, t_pass;

MCCefAuthScheme t_auth;

if (t_success)

t_success = MCCefAuthSchemeFromCefString(p_method, t_auth);

if (t_success)

t_success = m_owner->PlatformGetAuthCredentials(p_is_proxy, m_last_request_url, p_realm, t_auth, t_user, t_pass);

if (t_success)

t_success = !t_user.empty() && !t_pass.empty();

if (t_success)

p_callback->Continue(t_user, t_pass);

return t_success;

}

// CefDownloadHandler interface

// Methods called on UI thread

#if 0

// TODO - Implement OnDownload callback

virtual void OnBeforeDownload(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefDownloadItem> p_item, const CefString & p_suggested_name, CefRefPtr<CefBeforeDownloadCallback> p_callback) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return;

bool t_cancel;

t_cancel = false;

CefString t_url;

t_url = p_item->GetURL();

char *t_url_str;

t_url_str = nil;

/* UNCHECKED */ MCCefStringToUtf8String(t_url, t_url_str);

CB_DownloadRequest(m_owner->GetInst(), t_url_str, &t_cancel);

if (t_url_str != nil)

MCCStringFree(t_url_str);

CefString t_download_path;

if (!t_cancel)

p_callback->Continue(t_download_path, false);

}

#endif

// CefLoadHandler interface

// Methods called on UI thread or render process main thread

virtual void OnLoadStart(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return;

// render process may have restarted so resend js handler list

m_owner->SyncJavaScriptHandlers();

CefString t_url, t_error;

CefLoadHandler::ErrorCode t_error_code;

bool t_is_error;

t_is_error = FetchLoadErrorFrame(p_frame->GetIdentifier(), t_url, t_error, t_error_code);

if (!t_is_error)

t_url = p_frame->GetURL();

if (IgnoreUrl(t_url))

return;

char *t_url_str;

t_url_str = nil;

/* UNCHECKED */ MCCefStringToUtf8String(t_url, t_url_str);

bool t_frame;

t_frame = !p_frame->IsMain();

if (t_is_error)

{

if (t_error_code == ERR_UNKNOWN_URL_SCHEME)

m_owner->OnNavigationRequestUnhandled(t_frame, t_url_str);

}

else

{

if (!t_frame)

m_owner->OnNavigationBegin(t_frame, t_url_str);

m_owner->OnDocumentLoadBegin(t_frame, t_url_str);

}

if (t_url_str != nil)

MCCStringFree(t_url_str);

}

virtual void OnLoadEnd(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, int p_http_status_code) OVERRIDE

{

// IM-2014-07-21: [[ Bug 12296 ]] If browser has been closed then exit

if (nil == m_owner)

return;

CefString t_url, t_error;

CefLoadHandler::ErrorCode t_error_code;

bool t_is_error;

t_is_error = RemoveLoadErrorFrame(p_frame->GetIdentifier(), t_url, t_error, t_error_code);

if (!t_is_error)

t_url = p_frame->GetURL();

if (IgnoreUrl(t_url))

return CefLoadHandler::OnLoadEnd(p_browser, p_frame, p_http_status_code);

char *t_url_str;

t_url_str = nil;

/* UNCHECKED */ MCCefStringToUtf8String(t_url, t_url_str);

bool t_frame;

t_frame = !p_frame->IsMain();

if (t_is_error)

{