WebView lifespan, use release CEF in debug build

Build/CMake/Modules/AtomicWebView.cmake

@@ -24,11 +24,18 @@ endif()
 if(OS_MACOSX)
     set(CEF_STANDARD_LIBS "-lpthread" "-framework Cocoa" "-framework AppKit")
     set(CEF_LIBTYPE SHARED)
-    set(CEF_BINARY_DIR "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/$<CONFIGURATION>")
-    set(CEF_BINARY_DIR_DEBUG "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/Debug")
+
+    # using release
+    #set(CEF_BINARY_DIR "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/$<CONFIGURATION>")
+    set(CEF_BINARY_DIR "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/Release")
+
     set(CEF_BINARY_DIR_RELEASE "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/Release")
-    set(CEF_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/Chromium Embedded Framework.framework/Chromium Embedded Framework")
     set(CEF_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/Chromium Embedded Framework.framework/Chromium Embedded Framework")
+
+    # using release
+    set(CEF_BINARY_DIR_DEBUG "${CMAKE_SOURCE_DIR}/Submodules/CEF/MacOSX/Release")
+    set(CEF_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/Chromium Embedded Framework.framework/Chromium Embedded Framework")
+
 endif()
 
 #

Source/AtomicWebView/WebBrowserHost.cpp

@@ -1,11 +1,15 @@
 
+#include <list>
+
 #include <SDL/include/SDL.h>
 #include <ThirdParty/SDL/include/SDL_syswm.h>
 
 #include <ThirdParty/CEF/include/cef_app.h>
 #include <ThirdParty/CEF/include/cef_client.h>
-#include <ThirdParty/CEF/include/cef_render_handler.h>
 #include <ThirdParty/CEF/include/wrapper/cef_helpers.h>
+#include <ThirdParty/CEF/include/base/cef_bind.h>
+#include <ThirdParty/CEF/include/wrapper/cef_closure_task.h>
+
 
 #include <Atomic/Core/ProcessUtils.h>
 #include <Atomic/Core/CoreEvents.h>
@@ -16,38 +20,97 @@
 #include "WebClient.h"
 #include "WebBrowserHost.h"
 
-class SimpleApp : public CefApp,
-        public CefBrowserProcessHandler {
+namespace Atomic
+{
+
+#ifdef ATOMIC_PLATFORM_OSX
+void* GetNSWindowContentView(void* window);
+#endif
+
+class WebBrowserHostPrivate : public CefLifeSpanHandler
+{
+    friend class WebBrowserHost;
+
 public:
-    SimpleApp();
 
-    // CefApp methods:
-    virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
-    OVERRIDE { return this; }
+    WebBrowserHostPrivate(WebBrowserHost* host)
+    {
 
-    // CefBrowserProcessHandler methods:
-    virtual void OnContextInitialized() OVERRIDE;
+        host_ = host;
+    }
 
-private:
-    // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(SimpleApp);
-};
+    virtual ~WebBrowserHostPrivate()
+    {
+        host_ = 0;
+    }
 
-SimpleApp::SimpleApp() {
-}
+    // CefLifeSpanHandler methods:
+    virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE
+    {
+        CEF_REQUIRE_UI_THREAD();
+        browsers_.Push(browser);
+    }
 
-void SimpleApp::OnContextInitialized() {
+    virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE
+    {
+        return false;
+    }
 
-    CEF_REQUIRE_UI_THREAD();
+    virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE
+    {
+        CEF_REQUIRE_UI_THREAD();
+
+        // Remove from the list of existing browsers.
+        Vector<CefRefPtr<CefBrowser>>::Iterator itr = browsers_.Begin();
+        while (itr != browsers_.End())
+        {
+            if ((*itr)->IsSame(browser))
+            {
+                browsers_.Erase(itr);
+                break;
+            }
+
+            itr++;
+        }
+    }
 
-}
+    void CloseAllBrowsers(bool force_close)
+    {
+        if (!CefCurrentlyOn(TID_UI))
+        {
+            // Execute on the UI thread.
+            CefPostTask(TID_UI,
+                        base::Bind(&WebBrowserHostPrivate::CloseAllBrowsers, this, force_close));
 
-namespace Atomic
-{
+            return;
+        }
 
-#ifdef ATOMIC_PLATFORM_OSX
-void* GetNSWindowContentView(void* window);
-#endif
+        if (!browsers_.Size())
+            return;
+
+        // make a copy of vector, as we'll be erasing as we go
+        Vector<CefRefPtr<CefBrowser>> browsers = browsers_;
+
+        Vector<CefRefPtr<CefBrowser>>::Iterator itr = browsers.Begin();
+
+        while (itr != browsers.End())
+        {
+            (*itr)->GetHost()->CloseBrowser(force_close);
+            itr++;
+        }
+
+        browsers_.Clear();
+    }
+
+    IMPLEMENT_REFCOUNTING(WebBrowserHostPrivate);
+
+private:
+
+    Vector<CefRefPtr<CefBrowser>> browsers_;
+
+    WeakPtr<WebBrowserHost> host_;
+
+};
 
 WebBrowserHost::WebBrowserHost(Context* context) : Object (context)
 {
@@ -79,15 +142,25 @@ WebBrowserHost::WebBrowserHost(Context* context) : Object (context)
         LOGERROR("CefInitialize - Error");
     }
 
+    d_ = new WebBrowserHostPrivate(this);
+    d_->AddRef();
+
     SubscribeToEvent(E_BEGINFRAME, HANDLER(WebBrowserHost, HandleBeginFrame));
 
 }
 
 WebBrowserHost::~WebBrowserHost()
 {
+    d_->CloseAllBrowsers(true);
+    d_->Release();
     CefShutdown();
 }
 
+CefLifeSpanHandler* WebBrowserHost::GetCefLifeSpanHandler()
+{
+    return d_;
+}
+
 bool WebBrowserHost::CreateBrowser(WebClient* webClient)
 {
     CefWindowInfo windowInfo;

Source/AtomicWebView/WebBrowserHost.h

@@ -3,9 +3,12 @@
 
 #pragma once
 
+class CefLifeSpanHandler;
+
 namespace Atomic
 {
 
+class WebBrowserHostPrivate;
 class WebClient;
 
 class ATOMIC_API WebBrowserHost : public Object
@@ -20,10 +23,14 @@ public:
 
     bool CreateBrowser(WebClient* webClient);
 
+    CefLifeSpanHandler* GetCefLifeSpanHandler();
+
 private:
 
     void HandleBeginFrame(StringHash eventType, VariantMap& eventData);
 
+    WebBrowserHostPrivate* d_;
+
 };
 
 }

Source/AtomicWebView/WebClient.cpp

@@ -1,6 +1,8 @@
 
 #include <ThirdParty/CEF/include/cef_client.h>
 
+
+#include "WebBrowserHost.h"
 #include "WebClient.h"
 
 namespace Atomic
@@ -16,9 +18,11 @@ public:
     {
 
         webClient_ = client;
+        webBrowserHost_ = webClient_->GetSubsystem<WebBrowserHost>();
     }
 
-    CefRefPtr<CefRenderHandler> GetRenderHandler() OVERRIDE {
+    CefRefPtr<CefRenderHandler> GetRenderHandler() OVERRIDE
+    {
 
         if (webClient_->renderHandler_.Null())
             return nullptr;
@@ -27,10 +31,25 @@ public:
 
     }
 
-    IMPLEMENT_REFCOUNTING(WebClientPrivate)
+    virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE
+    {
+        return webBrowserHost_->GetCefLifeSpanHandler();
+    }
+
+    bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                  CefProcessId source_process,
+                                  CefRefPtr<CefProcessMessage> message) OVERRIDE
+    {
+        return false;
+    }
+
+
+
+    IMPLEMENT_REFCOUNTING(WebClientPrivate);
 
 private:
 
+    WeakPtr<WebBrowserHost> webBrowserHost_;
     WeakPtr<WebClient> webClient_;
 
 };
@@ -39,12 +58,12 @@ private:
 WebClient::WebClient(Context* context) : Object(context)
 {
     d_ = new WebClientPrivate(this);
-    d_->AddRef();
 }
 
 WebClient::~WebClient()
 {
-    d_->Release();
+    renderHandler_ = 0;
+    //d_->Release();
 }
 
 void WebClient::SetWebRenderHandler(WebRenderHandler* handler)

Source/AtomicWebView/WebTexture2D.cpp

@@ -63,7 +63,7 @@ WebTexture2D::WebTexture2D(Context* context, int width, int height) : WebRenderH
 
 WebTexture2D::~WebTexture2D()
 {
-    d_->Release();
+    //d_->Release();
 }
 
 CefRenderHandler* WebTexture2D::GetCEFRenderHandler()