src/cobalt/dom/user_agent_data_test.cc - cobalt - Git at Google

 // Copyright 2021 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <string>

 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/optional.h"
 #include "cobalt/bindings/testing/utils.h"
 #include "cobalt/browser/user_agent_platform_info.h"
 #include "cobalt/css_parser/parser.h"
 #include "cobalt/cssom/viewport_size.h"
 #include "cobalt/dom/global_stats.h"
 #include "cobalt/dom/local_storage_database.h"
 #include "cobalt/dom/navigator.h"
 #include "cobalt/dom/navigator_ua_data.h"
 #include "cobalt/dom/testing/gtest_workarounds.h"
 #include "cobalt/dom/testing/stub_environment_settings.h"
 #include "cobalt/dom/window.h"
 #include "cobalt/dom_parser/parser.h"
 #include "cobalt/h5vcc/h5vcc.h"
 #include "cobalt/loader/fetcher_factory.h"
 #include "cobalt/loader/loader_factory.h"
 #include "cobalt/script/global_environment.h"
 #include "cobalt/script/javascript_engine.h"
 #include "cobalt/script/source_code.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using cobalt::cssom::ViewportSize;

 namespace cobalt {
 namespace dom {

 namespace {

 class UserAgentDataTest : public ::testing::Test {
  public:
   UserAgentDataTest()
       : environment_settings_(new testing::StubEnvironmentSettings),
         css_parser_(css_parser::Parser::Create()),
         dom_parser_(
             new dom_parser::Parser(base::Bind(&StubLoadCompleteCallback))),
         fetcher_factory_(new loader::FetcherFactory(NULL)),
         loader_factory_(new loader::LoaderFactory(
             "Test", fetcher_factory_.get(), NULL, null_debugger_hooks_, 0,
             base::ThreadPriority::DEFAULT)),
         local_storage_database_(NULL),
         url_("about:blank"),
         engine_(script::JavaScriptEngine::CreateEngine()),
         global_environment_(engine_->CreateGlobalEnvironment()) {
     InitializeEmptyPlatformInfo();
     window_ = new Window(
         environment_settings_.get(), ViewportSize(1920, 1080),
         base::kApplicationStateStarted, css_parser_.get(), dom_parser_.get(),
         fetcher_factory_.get(), loader_factory_.get(), NULL, NULL, NULL, NULL,
         NULL, NULL, &local_storage_database_, NULL, NULL, NULL, NULL,
         global_environment_->script_value_factory() /* script_value_factory */,
         NULL, NULL, url_, "", platform_info_.get(), "en-US", "en",
         base::Callback<void(const GURL&)>(),
         base::Bind(&StubLoadCompleteCallback), NULL,
         network_bridge::PostSender(), csp::kCSPRequired, kCspEnforcementEnable,
         base::Closure() /* csp_policy_changed */,
         base::Closure() /* ran_animation_frame_callbacks */,
         dom::Window::CloseCallback() /* window_close */,
         base::Closure() /* window_minimize */, NULL, NULL,
         dom::Window::OnStartDispatchEventCallback(),
         dom::Window::OnStopDispatchEventCallback(),
         dom::ScreenshotManager::ProvideScreenshotFunctionCallback(), NULL);

     // Make Navigator accessible via Window
     global_environment_->CreateGlobalObject(window_,
                                             environment_settings_.get());

     // Inject H5vcc interface to make it also accessible via Window
     h5vcc::H5vcc::Settings h5vcc_settings;
     h5vcc_settings.media_module = NULL;
     h5vcc_settings.network_module = NULL;
 #if SB_IS(EVERGREEN)
     h5vcc_settings.updater_module = NULL;
 #endif
     h5vcc_settings.account_manager = NULL;
     h5vcc_settings.event_dispatcher = &event_dispatcher_;
     h5vcc_settings.user_agent_data = window_->navigator()->user_agent_data();
     h5vcc_settings.global_environment = global_environment_;
     global_environment_->Bind("h5vcc", scoped_refptr<script::Wrappable>(
                                            new h5vcc::H5vcc(h5vcc_settings)));
   }

   ~UserAgentDataTest() {
     global_environment_->SetReportEvalCallback(base::Closure());
     global_environment_->SetReportErrorCallback(
         script::GlobalEnvironment::ReportErrorCallback());
     window_->DispatchEvent(new dom::Event(base::Tokens::unload()));

     window_ = nullptr;
     global_environment_ = nullptr;
     EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   }

   bool EvaluateScript(const std::string& js_code, std::string* result);

   void SetUp() override;

  private:
   static void StubLoadCompleteCallback(
       const base::Optional<std::string>& error) {}
   const std::unique_ptr<testing::StubEnvironmentSettings> environment_settings_;
   base::NullDebuggerHooks null_debugger_hooks_;
   base::MessageLoop message_loop_;
   std::unique_ptr<css_parser::Parser> css_parser_;
   std::unique_ptr<dom_parser::Parser> dom_parser_;
   std::unique_ptr<loader::FetcherFactory> fetcher_factory_;
   std::unique_ptr<loader::LoaderFactory> loader_factory_;
   dom::LocalStorageDatabase local_storage_database_;
   GURL url_;
   std::unique_ptr<script::JavaScriptEngine> engine_;
   base::EventDispatcher event_dispatcher_;
   scoped_refptr<script::GlobalEnvironment> global_environment_;
   std::unique_ptr<browser::UserAgentPlatformInfo> platform_info_;
   scoped_refptr<Window> window_;

   void InitializeEmptyPlatformInfo();
 };

 bool UserAgentDataTest::EvaluateScript(const std::string& js_code,
                                        std::string* result) {
   DCHECK(global_environment_);
   scoped_refptr<script::SourceCode> source_code =
       script::SourceCode::CreateSourceCode(
           js_code, base::SourceLocation(__FILE__, __LINE__, 1));

   global_environment_->EnableEval();
   global_environment_->SetReportEvalCallback(base::Closure());
   bool succeeded = global_environment_->EvaluateScript(source_code, result);
   return succeeded;
 }

 void UserAgentDataTest::SetUp() {
   // Let's first check that the Web API is by default disabled, and that the
   // switch to turn it on works
   std::string result;
   EXPECT_TRUE(EvaluateScript("navigator.userAgentData", &result));
   EXPECT_FALSE(bindings::testing::IsAcceptablePrototypeString("NavigatorUAData",
                                                               result));

   EXPECT_TRUE(
       EvaluateScript("h5vcc.settings.set('NavigatorUAData', 1)", &result));
   EXPECT_EQ("true", result);

   EXPECT_TRUE(EvaluateScript("navigator.userAgentData", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("NavigatorUAData",
                                                              result));
 }

 void UserAgentDataTest::InitializeEmptyPlatformInfo() {
   platform_info_.reset(new browser::UserAgentPlatformInfo());

   platform_info_->set_starboard_version("");
   platform_info_->set_os_name_and_version("");
   platform_info_->set_original_design_manufacturer("");
   platform_info_->set_device_type(kSbSystemDeviceTypeUnknown);
   platform_info_->set_chipset_model_number("");
   platform_info_->set_model_year("");
   platform_info_->set_firmware_version("");
   platform_info_->set_brand("");
   platform_info_->set_model("");
   platform_info_->set_aux_field("");
   platform_info_->set_connection_type(base::nullopt);
   platform_info_->set_javascript_engine_version("");
   platform_info_->set_rasterizer_type("");
   platform_info_->set_evergreen_version("");
   platform_info_->set_cobalt_version("");
   platform_info_->set_cobalt_build_version_number("");
   platform_info_->set_build_configuration("");
 }

 }  // namespace

 TEST_F(UserAgentDataTest, Brands) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("navigator.userAgentData.brands", &result));
   EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Object", result));
 }

 TEST_F(UserAgentDataTest, Mobile) {
   std::string result;
   EXPECT_TRUE(EvaluateScript("navigator.userAgentData.mobile", &result));
   EXPECT_EQ("false", result);
 }

 TEST_F(UserAgentDataTest, GetHighEntropyValues) {
   std::string result;
   EXPECT_TRUE(
       EvaluateScript("navigator.userAgentData.getHighEntropyValues", &result));
   EXPECT_PRED_FORMAT2(::testing::IsSubstring, "function getHighEntropyValues()",
                       result.c_str());
   EXPECT_TRUE(EvaluateScript("navigator.userAgentData.getHighEntropyValues([])",
                              &result));
   EXPECT_TRUE(
       bindings::testing::IsAcceptablePrototypeString("Promise", result));
 }

 }  // namespace dom
 }  // namespace cobalt
	// Copyright 2021 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <string>

	#include "base/bind.h"
	#include "base/callback.h"
	#include "base/optional.h"
	#include "cobalt/bindings/testing/utils.h"
	#include "cobalt/browser/user_agent_platform_info.h"
	#include "cobalt/css_parser/parser.h"
	#include "cobalt/cssom/viewport_size.h"
	#include "cobalt/dom/global_stats.h"
	#include "cobalt/dom/local_storage_database.h"
	#include "cobalt/dom/navigator.h"
	#include "cobalt/dom/navigator_ua_data.h"
	#include "cobalt/dom/testing/gtest_workarounds.h"
	#include "cobalt/dom/testing/stub_environment_settings.h"
	#include "cobalt/dom/window.h"
	#include "cobalt/dom_parser/parser.h"
	#include "cobalt/h5vcc/h5vcc.h"
	#include "cobalt/loader/fetcher_factory.h"
	#include "cobalt/loader/loader_factory.h"
	#include "cobalt/script/global_environment.h"
	#include "cobalt/script/javascript_engine.h"
	#include "cobalt/script/source_code.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using cobalt::cssom::ViewportSize;

	namespace cobalt {
	namespace dom {

	namespace {

	class UserAgentDataTest : public ::testing::Test {
	public:
	UserAgentDataTest()
	: environment_settings_(new testing::StubEnvironmentSettings),
	css_parser_(css_parser::Parser::Create()),
	dom_parser_(
	new dom_parser::Parser(base::Bind(&StubLoadCompleteCallback))),
	fetcher_factory_(new loader::FetcherFactory(NULL)),
	loader_factory_(new loader::LoaderFactory(
	"Test", fetcher_factory_.get(), NULL, null_debugger_hooks_, 0,
	base::ThreadPriority::DEFAULT)),
	local_storage_database_(NULL),
	url_("about:blank"),
	engine_(script::JavaScriptEngine::CreateEngine()),
	global_environment_(engine_->CreateGlobalEnvironment()) {
	InitializeEmptyPlatformInfo();
	window_ = new Window(
	environment_settings_.get(), ViewportSize(1920, 1080),
	base::kApplicationStateStarted, css_parser_.get(), dom_parser_.get(),
	fetcher_factory_.get(), loader_factory_.get(), NULL, NULL, NULL, NULL,
	NULL, NULL, &local_storage_database_, NULL, NULL, NULL, NULL,
	global_environment_->script_value_factory() /* script_value_factory */,
	NULL, NULL, url_, "", platform_info_.get(), "en-US", "en",
	base::Callback<void(const GURL&)>(),
	base::Bind(&StubLoadCompleteCallback), NULL,
	network_bridge::PostSender(), csp::kCSPRequired, kCspEnforcementEnable,
	base::Closure() /* csp_policy_changed */,
	base::Closure() /* ran_animation_frame_callbacks */,
	dom::Window::CloseCallback() /* window_close */,
	base::Closure() /* window_minimize */, NULL, NULL,
	dom::Window::OnStartDispatchEventCallback(),
	dom::Window::OnStopDispatchEventCallback(),
	dom::ScreenshotManager::ProvideScreenshotFunctionCallback(), NULL);

	// Make Navigator accessible via Window
	global_environment_->CreateGlobalObject(window_,
	environment_settings_.get());

	// Inject H5vcc interface to make it also accessible via Window
	h5vcc::H5vcc::Settings h5vcc_settings;
	h5vcc_settings.media_module = NULL;
	h5vcc_settings.network_module = NULL;
	#if SB_IS(EVERGREEN)
	h5vcc_settings.updater_module = NULL;
	#endif
	h5vcc_settings.account_manager = NULL;
	h5vcc_settings.event_dispatcher = &event_dispatcher_;
	h5vcc_settings.user_agent_data = window_->navigator()->user_agent_data();
	h5vcc_settings.global_environment = global_environment_;
	global_environment_->Bind("h5vcc", scoped_refptr<script::Wrappable>(
	new h5vcc::H5vcc(h5vcc_settings)));
	}

	~UserAgentDataTest() {
	global_environment_->SetReportEvalCallback(base::Closure());
	global_environment_->SetReportErrorCallback(
	script::GlobalEnvironment::ReportErrorCallback());
	window_->DispatchEvent(new dom::Event(base::Tokens::unload()));

	window_ = nullptr;
	global_environment_ = nullptr;
	EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
	}

	bool EvaluateScript(const std::string& js_code, std::string* result);

	void SetUp() override;

	private:
	static void StubLoadCompleteCallback(
	const base::Optional<std::string>& error) {}
	const std::unique_ptr<testing::StubEnvironmentSettings> environment_settings_;
	base::NullDebuggerHooks null_debugger_hooks_;
	base::MessageLoop message_loop_;
	std::unique_ptr<css_parser::Parser> css_parser_;
	std::unique_ptr<dom_parser::Parser> dom_parser_;
	std::unique_ptr<loader::FetcherFactory> fetcher_factory_;
	std::unique_ptr<loader::LoaderFactory> loader_factory_;
	dom::LocalStorageDatabase local_storage_database_;
	GURL url_;
	std::unique_ptr<script::JavaScriptEngine> engine_;
	base::EventDispatcher event_dispatcher_;
	scoped_refptr<script::GlobalEnvironment> global_environment_;
	std::unique_ptr<browser::UserAgentPlatformInfo> platform_info_;
	scoped_refptr<Window> window_;

	void InitializeEmptyPlatformInfo();
	};

	bool UserAgentDataTest::EvaluateScript(const std::string& js_code,
	std::string* result) {
	DCHECK(global_environment_);
	scoped_refptr<script::SourceCode> source_code =
	script::SourceCode::CreateSourceCode(
	js_code, base::SourceLocation(__FILE__, __LINE__, 1));

	global_environment_->EnableEval();
	global_environment_->SetReportEvalCallback(base::Closure());
	bool succeeded = global_environment_->EvaluateScript(source_code, result);
	return succeeded;
	}

	void UserAgentDataTest::SetUp() {
	// Let's first check that the Web API is by default disabled, and that the
	// switch to turn it on works
	std::string result;
	EXPECT_TRUE(EvaluateScript("navigator.userAgentData", &result));
	EXPECT_FALSE(bindings::testing::IsAcceptablePrototypeString("NavigatorUAData",
	result));

	EXPECT_TRUE(
	EvaluateScript("h5vcc.settings.set('NavigatorUAData', 1)", &result));
	EXPECT_EQ("true", result);

	EXPECT_TRUE(EvaluateScript("navigator.userAgentData", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("NavigatorUAData",
	result));
	}

	void UserAgentDataTest::InitializeEmptyPlatformInfo() {
	platform_info_.reset(new browser::UserAgentPlatformInfo());

	platform_info_->set_starboard_version("");
	platform_info_->set_os_name_and_version("");
	platform_info_->set_original_design_manufacturer("");
	platform_info_->set_device_type(kSbSystemDeviceTypeUnknown);
	platform_info_->set_chipset_model_number("");
	platform_info_->set_model_year("");
	platform_info_->set_firmware_version("");
	platform_info_->set_brand("");
	platform_info_->set_model("");
	platform_info_->set_aux_field("");
	platform_info_->set_connection_type(base::nullopt);
	platform_info_->set_javascript_engine_version("");
	platform_info_->set_rasterizer_type("");
	platform_info_->set_evergreen_version("");
	platform_info_->set_cobalt_version("");
	platform_info_->set_cobalt_build_version_number("");
	platform_info_->set_build_configuration("");
	}

	} // namespace

	TEST_F(UserAgentDataTest, Brands) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("navigator.userAgentData.brands", &result));
	EXPECT_TRUE(bindings::testing::IsAcceptablePrototypeString("Object", result));
	}

	TEST_F(UserAgentDataTest, Mobile) {
	std::string result;
	EXPECT_TRUE(EvaluateScript("navigator.userAgentData.mobile", &result));
	EXPECT_EQ("false", result);
	}

	TEST_F(UserAgentDataTest, GetHighEntropyValues) {
	std::string result;
	EXPECT_TRUE(
	EvaluateScript("navigator.userAgentData.getHighEntropyValues", &result));
	EXPECT_PRED_FORMAT2(::testing::IsSubstring, "function getHighEntropyValues()",
	result.c_str());
	EXPECT_TRUE(EvaluateScript("navigator.userAgentData.getHighEntropyValues([])",
	&result));
	EXPECT_TRUE(
	bindings::testing::IsAcceptablePrototypeString("Promise", result));
	}

	} // namespace dom
	} // namespace cobalt