Smoketest/1.0.3415 testing

SampleApps/WebView2APISample/AppWindow.h

@@ -39,17 +39,20 @@ struct WebViewCreateOption
     WebViewCreateEntry entry = WebViewCreateEntry::OTHER;
     bool useOSRegion = false;
     std::optional<COREWEBVIEW2_COLOR> bg_color;
+    bool useWco = false;
     WebViewCreateOption()
     {
     }
     WebViewCreateOption(
         const std::wstring& profile_, bool inPrivate, const std::wstring& downloadPath,
-        const std::wstring& scriptLocale_, WebViewCreateEntry entry_, bool useOSRegion_
-        )
+        const std::wstring& scriptLocale_, WebViewCreateEntry entry_, bool useOSRegion_,
+        bool useWco_ = false, const std::optional<COREWEBVIEW2_COLOR>& bg_color_ = std::nullopt)
         : profile(profile_), isInPrivate(inPrivate), downloadPath(downloadPath),
-          scriptLocale(scriptLocale_), entry(entry_), useOSRegion(useOSRegion_)
+          scriptLocale(scriptLocale_), entry(entry_), useOSRegion(useOSRegion_),
+          useWco(useWco_), bg_color(bg_color_)
     {
     }
+
     WebViewCreateOption(const WebViewCreateOption& opt)
     {
         profile = opt.profile;
@@ -58,6 +61,8 @@ struct WebViewCreateOption
         scriptLocale = opt.scriptLocale;
         entry = opt.entry;
         useOSRegion = opt.useOSRegion;
+        useWco = opt.useWco;
+        bg_color = opt.bg_color;
     }
     void PopupDialog(AppWindow* app);
 };
@@ -222,11 +227,11 @@ class AppWindow
     bool ShouldMatchWord();
     bool SuppressDefaultFindDialog();
     bool IsCaseSensitive();
-    wil::com_ptr<ICoreWebView2ExperimentalFindOptions> SetDefaultFindOptions();
-    void SetupFindEventHandlers(wil::com_ptr<ICoreWebView2ExperimentalFind> webView2find);
+    wil::com_ptr<ICoreWebView2FindOptions> SetDefaultFindOptions();
+    void SetupFindEventHandlers(wil::com_ptr<ICoreWebView2Find> webView2find);
     // Find on Page member
     std::wstring m_findOnPageLastSearchTerm;
-    wil::com_ptr<ICoreWebView2ExperimentalFindOptions> findOptions;
+    wil::com_ptr<ICoreWebView2FindOptions> findOptions;
     EventRegistrationToken m_activeMatchIndexChangedToken = {};
     EventRegistrationToken m_matchCountChangedToken = {};
 

SampleApps/WebView2APISample/ScenarioDedicatedWorker.cpp

@@ -0,0 +1,129 @@
+// Copyright (C) Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "stdafx.h"
+
+#include "CheckFailure.h"
+#include "ScenarioDedicatedWorker.h"
+
+using namespace Microsoft::WRL;
+
+ScenarioDedicatedWorker::ScenarioDedicatedWorker(AppWindow* appWindow) : m_appWindow(appWindow)
+{
+    //! [DedicatedWorkerCreated]
+    m_appWindow->GetWebView()->QueryInterface(IID_PPV_ARGS(&m_webView2Experimental_30));
+    CHECK_FEATURE_RETURN_EMPTY(m_webView2Experimental_30);
+
+    CHECK_FAILURE(m_webView2Experimental_30->add_DedicatedWorkerCreated(
+        Callback<ICoreWebView2ExperimentalDedicatedWorkerCreatedEventHandler>(
+            [this](
+                ICoreWebView2* sender,
+                ICoreWebView2ExperimentalDedicatedWorkerCreatedEventArgs* args)
+            {
+                wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker;
+                CHECK_FAILURE(args->get_Worker(&dedicatedWorker));
+
+                wil::unique_cotaskmem_string scriptUri;
+                CHECK_FAILURE(dedicatedWorker->get_ScriptUri(&scriptUri));
+
+                std::wstring scriptUriStr(scriptUri.get());
+                m_appWindow->AsyncMessageBox(scriptUriStr, L"Dedicated worker is created");
+
+                // Subscribe to worker destroying event
+                dedicatedWorker->add_Destroying(
+                    Callback<ICoreWebView2ExperimentalDedicatedWorkerDestroyingEventHandler>(
+                        [this, scriptUriStr](
+                            ICoreWebView2ExperimentalDedicatedWorker* sender,
+                            IUnknown* args) -> HRESULT
+                        {
+                            /*Cleanup on worker destruction*/
+                            m_appWindow->AsyncMessageBox(
+                                scriptUriStr, L"Dedicated worker is destroyed");
+                            return S_OK;
+                        })
+                        .Get(),
+                    nullptr);
+
+                return S_OK;
+            })
+            .Get(),
+        &m_dedicatedWorkerCreatedToken));
+    //! [DedicatedWorkerCreated]
+
+    wil::com_ptr<ICoreWebView2_4> m_webView2_4;
+    m_appWindow->GetWebView()->QueryInterface(IID_PPV_ARGS(&m_webView2_4));
+    CHECK_FEATURE_RETURN_EMPTY(m_webView2_4);
+
+    CHECK_FAILURE(m_webView2_4->add_FrameCreated(
+        Callback<ICoreWebView2FrameCreatedEventHandler>(
+            [this](ICoreWebView2* sender, ICoreWebView2FrameCreatedEventArgs* args) -> HRESULT
+            {
+                wil::com_ptr<ICoreWebView2Frame> webviewFrame;
+                CHECK_FAILURE(args->get_Frame(&webviewFrame));
+
+                wil::com_ptr<ICoreWebView2ExperimentalFrame9> m_frameExperimental_9 =
+                    webviewFrame.try_query<ICoreWebView2ExperimentalFrame9>();
+
+                m_frameExperimental_9->add_DedicatedWorkerCreated(
+                    Callback<ICoreWebView2ExperimentalFrameDedicatedWorkerCreatedEventHandler>(
+                        [this](
+                            ICoreWebView2Frame* sender,
+                            ICoreWebView2ExperimentalDedicatedWorkerCreatedEventArgs* args)
+                            -> HRESULT
+                        {
+                            // frameInfo that created the worker.
+                            wil::com_ptr<ICoreWebView2FrameInfo> frameInfo;
+                            CHECK_FAILURE(args->get_OriginalSourceFrameInfo(&frameInfo));
+
+                            wil::com_ptr<ICoreWebView2FrameInfo2> frameInfo2;
+                            CHECK_FAILURE(frameInfo->QueryInterface(IID_PPV_ARGS(&frameInfo2)));
+
+                            wil::unique_cotaskmem_string frameSource;
+                            CHECK_FAILURE(frameInfo->get_Source(&frameSource));
+
+                            UINT32 source_frameId;
+                            CHECK_FAILURE(frameInfo2->get_FrameId(&source_frameId));
+
+                            wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker>
+                                dedicatedWorker;
+                            CHECK_FAILURE(args->get_Worker(&dedicatedWorker));
+
+                            wil::unique_cotaskmem_string scriptUri;
+                            CHECK_FAILURE(dedicatedWorker->get_ScriptUri(&scriptUri));
+
+                            std::wstring scriptUriStr(scriptUri.get());
+                            m_appWindow->AsyncMessageBox(
+                                scriptUriStr, L"Dedicated worker is created");
+
+                            // Subscribe to worker destroying event
+                            dedicatedWorker->add_Destroying(
+                                Callback<
+                                    ICoreWebView2ExperimentalDedicatedWorkerDestroyingEventHandler>(
+                                    [this, scriptUriStr](
+                                        ICoreWebView2ExperimentalDedicatedWorker* sender,
+                                        IUnknown* args) -> HRESULT
+                                    {
+                                        /*Cleanup on worker destruction*/
+                                        m_appWindow->AsyncMessageBox(
+                                            scriptUriStr, L"Dedicated worker is destroyed");
+                                        return S_OK;
+                                    })
+                                    .Get(),
+                                nullptr);
+
+                            return S_OK;
+                        })
+                        .Get(),
+                    nullptr);
+
+                return S_OK;
+            })
+            .Get(),
+        nullptr));
+}
+
+ScenarioDedicatedWorker::~ScenarioDedicatedWorker()
+{
+    m_webView2Experimental_30->remove_DedicatedWorkerCreated(m_dedicatedWorkerCreatedToken);
+}

SampleApps/WebView2APISample/ScenarioDedicatedWorker.h

@@ -0,0 +1,20 @@
+// Copyright (C) Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "stdafx.h"
+
+#include "AppWindow.h"
+#include "ComponentBase.h"
+
+class ScenarioDedicatedWorker : public ComponentBase
+{
+public:
+    ScenarioDedicatedWorker(AppWindow* appWindow);
+    ~ScenarioDedicatedWorker() override;
+
+private:
+    AppWindow* m_appWindow;
+    wil::com_ptr<ICoreWebView2Experimental30> m_webView2Experimental_30;
+    EventRegistrationToken m_dedicatedWorkerCreatedToken = {};
+};

SampleApps/WebView2APISample/ScenarioDedicatedWorkerPostMessage.cpp

@@ -0,0 +1,123 @@
+// Copyright (C) Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "stdafx.h"
+#include <sstream>
+
+#include "CheckFailure.h"
+#include "TextInputDialog.h"
+
+#include "ScenarioDedicatedWorkerPostMessage.h"
+
+using namespace Microsoft::WRL;
+
+static constexpr WCHAR c_samplePath[] = L"ScenarioDedicatedWorkerPostMessage.html";
+
+ScenarioDedicatedWorkerPostMessage::ScenarioDedicatedWorkerPostMessage(AppWindow* appWindow)
+    : m_appWindow(appWindow)
+{
+    //! [DedicatedWorkerCreated]
+    m_appWindow->GetWebView()->QueryInterface(IID_PPV_ARGS(&m_webView2Experimental_30));
+    CHECK_FEATURE_RETURN_EMPTY(m_webView2Experimental_30);
+
+    CHECK_FAILURE(m_webView2Experimental_30->add_DedicatedWorkerCreated(
+        Callback<ICoreWebView2ExperimentalDedicatedWorkerCreatedEventHandler>(
+            [this](
+                ICoreWebView2* sender,
+                ICoreWebView2ExperimentalDedicatedWorkerCreatedEventArgs* args)
+            {
+                wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker;
+                CHECK_FAILURE(args->get_Worker(&dedicatedWorker));
+
+                wil::unique_cotaskmem_string scriptUri;
+                CHECK_FAILURE(dedicatedWorker->get_ScriptUri(&scriptUri));
+
+                std::wstring scriptUriStr(scriptUri.get());
+                m_appWindow->AsyncMessageBox(scriptUriStr, L"Dedicated worker is created");
+
+                SetupEventsOnDedicatedWorker(dedicatedWorker);
+                ComputeWithDedicatedWorker(dedicatedWorker);
+
+                return S_OK;
+            })
+            .Get(),
+        &m_dedicatedWorkerCreatedToken));
+    //! [DedicatedWorkerCreated]
+
+    // Turn off this scenario if we navigate away from the sample page.
+    CHECK_FAILURE(m_appWindow->GetWebView()->add_ContentLoading(
+        Callback<ICoreWebView2ContentLoadingEventHandler>(
+            [this](ICoreWebView2* sender, ICoreWebView2ContentLoadingEventArgs* args) -> HRESULT
+            {
+                wil::unique_cotaskmem_string uri;
+                sender->get_Source(&uri);
+                if (uri.get() != m_sampleUri)
+                {
+                    m_appWindow->DeleteComponent(this);
+                }
+                return S_OK;
+            })
+            .Get(),
+        &m_contentLoadingToken));
+
+    m_sampleUri = m_appWindow->GetLocalUri(c_samplePath);
+    CHECK_FAILURE(m_appWindow->GetWebView()->Navigate(m_sampleUri.c_str()));
+}
+
+void ScenarioDedicatedWorkerPostMessage::SetupEventsOnDedicatedWorker(
+    wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker)
+{
+    //! [WebMessageReceived]
+    dedicatedWorker->add_WebMessageReceived(
+        Callback<ICoreWebView2ExperimentalDedicatedWorkerWebMessageReceivedEventHandler>(
+            [this](
+                ICoreWebView2ExperimentalDedicatedWorker* sender,
+                ICoreWebView2WebMessageReceivedEventArgs* args) -> HRESULT
+            {
+                wil::unique_cotaskmem_string scriptUri;
+                CHECK_FAILURE(args->get_Source(&scriptUri));
+
+                wil::unique_cotaskmem_string messageRaw;
+                CHECK_FAILURE(args->TryGetWebMessageAsString(&messageRaw));
+                std::wstring messageFromWorker = messageRaw.get();
+
+                std::wstringstream message{};
+                message << L"Dedicated Worker: " << std::endl << scriptUri.get() << std::endl;
+                message << std::endl;
+                message << L"Message: " << std::endl << messageFromWorker << std::endl;
+                m_appWindow->AsyncMessageBox(message.str(), L"Message from Dedicated Worker");
+
+                return S_OK;
+            })
+            .Get(),
+        nullptr);
+    //! [WebMessageReceived]
+}
+
+void ScenarioDedicatedWorkerPostMessage::ComputeWithDedicatedWorker(
+    wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker)
+{
+    //! [PostWebMessageAsJson]
+    // Do not block from event handler
+    m_appWindow->RunAsync(
+        [this, dedicatedWorker]
+        {
+            TextInputDialog dialog(
+                m_appWindow->GetMainWindow(), L"Post Web Message JSON", L"Web message JSON",
+                L"Enter the web message as JSON.",
+                L"{\"command\":\"ADD\",\"first\":2,\"second\":3}");
+            // Ex: {"command":"ADD","first":2,"second":3}
+            if (dialog.confirmed)
+            {
+                dedicatedWorker->PostWebMessageAsJson(dialog.input.c_str());
+            }
+        });
+    //! [PostWebMessageAsJson]
+}
+
+ScenarioDedicatedWorkerPostMessage::~ScenarioDedicatedWorkerPostMessage()
+{
+    m_webView2Experimental_30->remove_DedicatedWorkerCreated(m_dedicatedWorkerCreatedToken);
+    m_appWindow->GetWebView()->remove_ContentLoading(m_contentLoadingToken);
+}

SampleApps/WebView2APISample/ScenarioDedicatedWorkerPostMessage.h

@@ -0,0 +1,27 @@
+// Copyright (C) Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "stdafx.h"
+
+#include "AppWindow.h"
+#include "ComponentBase.h"
+
+class ScenarioDedicatedWorkerPostMessage : public ComponentBase
+{
+public:
+    ScenarioDedicatedWorkerPostMessage(AppWindow* appWindow);
+    ~ScenarioDedicatedWorkerPostMessage() override;
+
+private:
+    void SetupEventsOnDedicatedWorker(
+        wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker);
+    void ComputeWithDedicatedWorker(
+        wil::com_ptr<ICoreWebView2ExperimentalDedicatedWorker> dedicatedWorker);
+
+    AppWindow* m_appWindow;
+    wil::com_ptr<ICoreWebView2Experimental30> m_webView2Experimental_30;
+    std::wstring m_sampleUri;
+    EventRegistrationToken m_contentLoadingToken = {};
+    EventRegistrationToken m_dedicatedWorkerCreatedToken = {};
+};