/* Copyright (C) 2003-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 <revolution/external.h>

#include "core.h"

#include "cefbrowser.h"

#include "cefbrowser_msg.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

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

// 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)

t_success = MCCStringToCardinal(t_tmp_string, t_int);

if (t_tmp_string != nil)

MCCStringFree(t_tmp_string);

if (t_success)

r_int = t_int;

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;

static MCRunloopActionRef s_runloop_action = nil;

void MCCefBrowserExternalInit(void)

{

// set up static vars

s_cef_initialised = false;

s_cefbrowser_initialised = false;

s_instance_count = 0;

s_runloop_action = nil;

}

void MCCefBrowserRunloopAction(void *p_context)

{

CefDoMessageLoopWork();

}

extern "C" int initialise_weak_link_cef(void);

#if defined(WIN32)

static const char *kCefProcessName = "revbrowser-cefprocess.exe";

static const char *kCefPathSeparatorStr = "\\";

static const char kCefPathSeparator = '\\';

#else

static const char *kCefProcessName = "revbrowser-cefprocess";

static const char *kCefPathSeparatorStr = "/";

static const char kCefPathSeparator = '/';

#endif

static bool __MCCefGetLibraryPath(char*& r_path)

{

int t_retval = EXTERNAL_SUCCESS;

void *t_module = nullptr;

if (t_module == nullptr)

{

LoadModuleByName("./CEF/libcef", &t_module, &t_retval);

if (t_retval != EXTERNAL_SUCCESS)

t_module = nullptr;

}

#if defined(WIN32) || defined(TARGET_PLATFORM_LINUX)

if (t_module == nullptr)

{

LoadModuleByName("./Externals/CEF/libcef", &t_module, &t_retval);

if (t_retval != EXTERNAL_SUCCESS)

t_module = nullptr;

}

#endif

char *t_module_path =

t_module != nullptr ? CopyNativePathOfModule(t_module, &t_retval)

: nullptr;

if (t_retval != EXTERNAL_SUCCESS)

t_module_path = nullptr;

UnloadModule(t_module, &t_retval);

if (t_module_path == nullptr)

{

return false;

}

char *t_last_sep =

strrchr(t_module_path,

kCefPathSeparator);

if (t_last_sep == nullptr)

{

free(t_module_path);

return false;

}

*t_last_sep = '\0';

r_path = t_module_path;

return true;

}

static bool __MCCefAppendPath(const char *p_base, const char *p_path, char *&r_path)

{

if (p_base == nil)

return MCCStringClone(p_path, r_path);

else if (MCCStringEndsWith(p_base, kCefPathSeparatorStr))

return MCCStringFormat(r_path, "%s%s", p_base, p_path);

else

return MCCStringFormat(r_path, "%s%s%s", p_base, kCefPathSeparatorStr, p_path);

}

static bool __MCCefBuildPath(const char *p_library_path,

const char *p_suffix,

cef_string_t* r_string)

{

char *t_process_path = nullptr;

if (!__MCCefAppendPath(p_library_path,

p_suffix,

t_process_path) ||

!MCCefStringFromUtf8String(t_process_path,

r_string))

{

free(t_process_path);

return false;

}

return true;

}

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

bool MCCefInitialise(void)

{

if (s_cef_initialised)

return true;

////////

char *t_library_path = nullptr;

if (!__MCCefGetLibraryPath(t_library_path))

return false;

////////

CefMainArgs t_args;

CefSettings t_settings;

t_settings.multi_threaded_message_loop = false;

t_settings.command_line_args_disabled = true;

t_settings.no_sandbox = true;

t_settings.log_severity = LOGSEVERITY_VERBOSE;

bool t_success = true;

if (t_success)

t_success = __MCCefBuildPath(t_library_path, kCefProcessName, &t_settings.browser_subprocess_path);

if (t_success)

t_success = __MCCefBuildPath(t_library_path, "locales", &t_settings.locales_dir_path);

if (t_success)

t_success = __MCCefBuildPath(t_library_path, "", &t_settings.resources_dir_path);

CefRefPtr<CefApp> t_app = nil;

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;

if (t_success)

{

t_success = initialise_weak_link_cef();

}

if (t_success)

t_success = MCCefInitialise();

if (t_success)

{

int t_result;

AddRunloopAction(MCCefBrowserRunloopAction, nil, &s_runloop_action, &t_result);

}

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;

// IM-2014-03-13: [[ revBrowserCEF ]] CEF library can't be cleanly shutdown and restarted - don't call finalise

// MCCefFinalise();

int t_result;

/* UNCHECKED */ RemoveRunloopAction(s_runloop_action, &t_result);

s_runloop_action = 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;

};

class MCCefBrowserClient : public CefClient, CefLifeSpanHandler, CefRequestHandler, CefDownloadHandler, CefLoadHandler, CefContextMenuHandler

{

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)

{

m_load_error_frames[p_id].url = p_url;

m_load_error_frames[p_id].error_message = p_error_msg;

}

bool RemoveLoadErrorFrame(int64_t p_id, CefString &r_error_url, CefString &r_error_msg)

{

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_error_url = t_iter->second.url;

r_error_msg = t_iter->second.error_message;

m_load_error_frames.erase(t_iter);

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; }

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);

}

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;

char **t_arg_strings;

t_arg_strings = 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;

// Convert message args to strings and pass to handler parameters

if (t_success)

{

t_arg_count = t_args->GetSize() - 1;

t_success = MCMemoryNewArray(t_arg_count, t_arg_strings);

}

for (uint32_t i = 0; i < t_arg_count; i++)

t_success = MCCefStringToUtf8String(t_args->GetString(i + 1), t_arg_strings[i]);

bool t_cancel;

if (t_success)

CB_Custom(m_owner->GetInst(), t_handler, t_arg_strings, t_arg_count, &t_cancel);

if (t_handler)

MCCStringFree(t_handler);

if (t_arg_strings != nil)

{

for (uint32_t i = 0; i < t_arg_count; i++)

if (t_arg_strings[i] != nil)

MCCStringFree(t_arg_strings[i]);

MCMemoryDeleteArray(t_arg_strings);

}

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

MCCefPlatformCloseBrowserWindow(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->GetNewWindow();

}

// 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 (p_frame->IsMain())

{

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

}

else

{

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

}

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>) 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

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);

}

// 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;

CefString t_url;

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);

if (p_frame->IsMain())

CB_NavigateComplete(m_owner->GetInst(), t_url_str);

else

CB_NavigateFrameComplete(m_owner->GetInst(), 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;

bool t_is_error;

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

/* TODO - Load error handling */

// For now we don't send a browser load error message - instead make sure documentComplete is sent with the correct url

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);

if (t_is_error)

{

char *t_err_str;

t_err_str = nil;

/* UNCHECKED */ MCCefStringToUtf8String(t_error, t_err_str);

if (p_frame->IsMain())

CB_DocumentFailed(m_owner->GetInst(), t_url_str, t_err_str);

else

CB_DocumentFrameFailed(m_owner->GetInst(), t_url_str, t_err_str);

if (t_err_str != nil)

MCCStringFree(t_err_str);

}

else

{

if (p_frame->IsMain())

CB_DocumentComplete(m_owner->GetInst(), t_url_str);

else

CB_DocumentFrameComplete(m_owner->GetInst(), t_url_str);

}

if (t_url_str != nil)

MCCStringFree(t_url_str);

}

virtual void OnLoadError(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, CefLoadHandler::ErrorCode p_error_code, const CefString &p_error_text, const CefString &p_failed_url) OVERRIDE

{

if (IgnoreUrl(p_failed_url))

return;

AddLoadErrorFrame(p_frame->GetIdentifier(), p_failed_url, p_error_text);

}

// ContextMenuHandler interface

// Methods called on UI thread

virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> p_browser, CefRefPtr<CefFrame> p_frame, CefRefPtr<CefContextMenuParams> p_params, CefRefPtr<CefMenuModel> p_model) OVERRIDE

{

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

if (nil == m_owner)

return;

// clearing the menu model prevents the context menu from opening

if (!m_owner->GetContextMenu())

p_model->Clear();

}

IMPLEMENT_REFCOUNTING(MCCefBrowserClient)

};

bool MCCefBrowserBase::Initialize()

{

// create client and browser

m_client = new (nothrow) MCCefBrowserClient(this);

CefWindowInfo t_window_info;

CefBrowserSettings t_settings;

// IM-2014-05-06: [[ Bug 12384 ]] Browser must be created with non-empty URL or setting

// htmltext will not work

CefString t_url("dummy:");

// IM-2014-05-06: [[ Bug 12384 ]] Prevent callback messages for dummy URL

m_client->AddIgnoreUrl(t_url);

PlatformConfigureWindow(t_window_info);

CefBrowserHost::CreateBrowserSync(t_window_info, m_client.get(), t_url, t_settings, NULL);

return m_browser != nil;

}

MCCefBrowserBase::MCCefBrowserBase()

{

MCCefIncrementInstanceCount();

m_browser = nil;

m_client = nil;

m_instance_id = 0;

m_send_advanced_messages = false;

m_show_context_menu = false;

m_allow_new_window = false;

}

MCCefBrowserBase::~MCCefBrowserBase(void)

{

if (m_browser != nil)

m_browser->GetHost()->CloseBrowser(false);

// IM-2014-07-21: [[ Bug 12296 ]] Notify client of browser being closed

if (m_client)

m_client->OnOwnerClosed();

m_browser = nil;

m_client = nil;

MCCefDecrementInstanceCount();

}

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

CWebBrowserBase *MCCefBrowserInstantiate(int p_window_id)

{

// IM-2014-03-18: [[ revBrowserCEF ]] Make sure cef library is loaded before trying to create browser

if (!MCCefBrowserInitialise())

return nil;

MCCefBrowserBase *t_browser;

if (!MCCefPlatformCreateBrowser(p_window_id, t_browser))

return nil;

if (!t_browser->Initialize())

{

delete t_browser;

return nil;

}

return t_browser;

}

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

void MCCefBrowserBase::OnCefBrowserCreated(CefRefPtr<CefBrowser> p_browser)

{

if (m_browser == nil)

m_browser = p_browser;

}

void MCCefBrowserBase::OnCefBrowserClosed(CefRefPtr<CefBrowser> p_browser)

{

}

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

CefRefPtr<CefBrowser> MCCefBrowserBase::GetCefBrowser(void)