starboard/shared/uwp/application_uwp.cc

// Copyright 2017 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 "starboard/shared/uwp/application_uwp.h"

#include <D3D11.h>
#include <D3D11_1.h>
#include <WinSock2.h>
#include <collection.h>
#include <mfapi.h>
#include <ppltasks.h>
#include <windows.graphics.display.core.h>
#include <windows.h>
#include <windows.system.display.h>

#include <cstdlib>
#include <memory>
#include <string>
#include <vector>

#include "starboard/common/device_type.h"
#include "starboard/common/file.h"
#include "starboard/common/log.h"
#include "starboard/common/mutex.h"
#include "starboard/common/queue.h"
#include "starboard/common/semaphore.h"
#include "starboard/common/string.h"
#include "starboard/common/system_property.h"
#include "starboard/common/thread.h"
#include "starboard/configuration_constants.h"
#include "starboard/event.h"
#include "starboard/input.h"
#include "starboard/shared/starboard/application.h"
#include "starboard/shared/starboard/audio_sink/audio_sink_internal.h"
#include "starboard/shared/starboard/media/key_system_supportability_cache.h"
#include "starboard/shared/starboard/media/mime_supportability_cache.h"
#include "starboard/shared/starboard/net_args.h"
#include "starboard/shared/starboard/net_log.h"
#include "starboard/shared/uwp/analog_thumbstick_input_thread.h"
#include "starboard/shared/uwp/app_accessors.h"
#include "starboard/shared/uwp/async_utils.h"
#include "starboard/shared/uwp/extended_resources_manager.h"
#include "starboard/shared/uwp/log_file_impl.h"
#include "starboard/shared/uwp/watchdog_log.h"
#include "starboard/shared/uwp/window_internal.h"
#include "starboard/shared/win32/thread_private.h"
#include "starboard/shared/win32/video_decoder.h"
#include "starboard/shared/win32/wchar_utils.h"
#include "starboard/system.h"

namespace starboard {

using Microsoft::WRL::ComPtr;
using shared::starboard::Application;
using shared::starboard::CommandLine;
using shared::starboard::kNetArgsCommandSwitchWait;
using shared::starboard::kNetLogCommandSwitchWait;
using shared::starboard::NetArgsWaitForPayload;
using shared::starboard::NetLogFlushThenClose;
using shared::starboard::NetLogWaitForClientConnected;
using shared::uwp::ApplicationUwp;
using shared::uwp::RunInMainThreadAsync;
using shared::uwp::WaitForResult;
using shared::win32::platformStringToString;
using shared::win32::stringToPlatformString;
using shared::win32::wchar_tToUTF8;
using ::starboard::shared::starboard::media::KeySystemSupportabilityCache;
using ::starboard::shared::starboard::media::MimeSupportabilityCache;
using Windows::ApplicationModel::SuspendingDeferral;
using Windows::ApplicationModel::SuspendingEventArgs;
using Windows::ApplicationModel::Activation::ActivationKind;
using Windows::ApplicationModel::Activation::DialReceiverActivatedEventArgs;
using Windows::ApplicationModel::Activation::IActivatedEventArgs;
using Windows::ApplicationModel::Activation::IProtocolActivatedEventArgs;
using Windows::ApplicationModel::Core::CoreApplication;
using Windows::ApplicationModel::Core::CoreApplicationView;
using Windows::ApplicationModel::Core::IFrameworkView;
using Windows::ApplicationModel::Core::IFrameworkViewSource;
using Windows::ApplicationModel::ExtendedExecution::ExtendedExecutionReason;
using Windows::ApplicationModel::ExtendedExecution::ExtendedExecutionResult;
using Windows::ApplicationModel::ExtendedExecution::
    ExtendedExecutionRevokedEventArgs;
using Windows::ApplicationModel::ExtendedExecution::ExtendedExecutionSession;
using Windows::Devices::Enumeration::DeviceInformation;
using Windows::Devices::Enumeration::DeviceInformationUpdate;
using Windows::Devices::Enumeration::DeviceWatcher;
using Windows::Devices::Enumeration::DeviceWatcherStatus;
using Windows::Foundation::EventHandler;
using Windows::Foundation::IAsyncOperation;
using Windows::Foundation::TimeSpan;
using Windows::Foundation::TypedEventHandler;
using Windows::Foundation::Uri;
using Windows::Foundation::Collections::IVectorView;
using Windows::Foundation::Metadata::ApiInformation;
using Windows::Globalization::Calendar;
using Windows::Graphics::Display::AdvancedColorInfo;
using Windows::Graphics::Display::AdvancedColorKind;
using Windows::Graphics::Display::DisplayInformation;
using Windows::Graphics::Display::HdrMetadataFormat;
using Windows::Graphics::Display::Core::HdmiDisplayColorSpace;
using Windows::Graphics::Display::Core::HdmiDisplayHdr2086Metadata;
using Windows::Graphics::Display::Core::HdmiDisplayHdrOption;
using Windows::Graphics::Display::Core::HdmiDisplayInformation;
using Windows::Graphics::Display::Core::HdmiDisplayMode;
using Windows::Media::Protection::HdcpProtection;
using Windows::Media::Protection::HdcpSession;
using Windows::Media::Protection::HdcpSetProtectionResult;
using Windows::Security::Authentication::Web::Core::WebTokenRequestResult;
using Windows::Security::Authentication::Web::Core::WebTokenRequestStatus;
using Windows::Security::Credentials::WebAccountProvider;
using Windows::Storage::FileAttributes;
using Windows::Storage::KnownFolders;
using Windows::Storage::StorageFile;
using Windows::Storage::StorageFolder;
using Windows::System::UserAuthenticationStatus;
using Windows::System::Threading::ThreadPoolTimer;
using Windows::System::Threading::TimerElapsedHandler;
using Windows::UI::Core::CoreDispatcherPriority;
using Windows::UI::Core::CoreProcessEventsOption;
using Windows::UI::Core::CoreWindow;
using Windows::UI::Core::DispatchedHandler;
using Windows::UI::Core::KeyEventArgs;
using Windows::UI::ViewManagement::ApplicationView;
using Windows::UI::ViewManagement::ApplicationViewScaling;

namespace {

const Platform::String ^ kGenericPnpMonitorAqs = ref new Platform::String(
    L"System.Devices.InterfaceClassGuid:=\"{e6f07b5f-ee97-4a90-b076-"
    L"33f57bf4eaa7}\" AND "
    L"System.Devices.InterfaceEnabled:=System.StructuredQueryType.Boolean#"
    L"True");

const uint32_t kYuv420BitsPerPixelForHdr10Mode = 24;

// The number of seconds to wait after requesting application stop. This is used
// to exit the app when a suspend has been requested. This is a temporary
// behavior that should be removed when not needed anymore.
const SbTime kAppExitWaitTime = kSbTimeSecond * 30;

// Per Microsoft, HdcpProtection::On means HDCP 1.x required.
const HdcpProtection kHDCPProtectionMode = HdcpProtection::On;

const int kWinSockVersionMajor = 2;
const int kWinSockVersionMinor = 2;

const char kDialParamPrefix[] = "cobalt-dial:?";
const char kLogPathSwitch[] = "xb1_log_file";
// A special log that the app will periodically write to. This allows
// tests to determine if the app is still alive.
const char kWatchDogLog[] = "xb1_watchdog_log";
const char kStarboardArgumentsPath[] = "arguments\\starboard_arguments.txt";
const int64_t kMaxArgumentFileSizeBytes = 4 * 1024 * 1024;

int main_return_value = 0;

// IDisplayRequest is both "non-agile" and apparently
// incompatible with Platform::Agile (it doesn't fully implement
// a thread marshaller). We must neither use ComPtr or Platform::Agile
// here. We manually create, access release on the main app thread only.
ABI::Windows::System::Display::IDisplayRequest* display_request = nullptr;

// If an argv[0] is required, fill it in with the result of
// GetModuleFileName()
std::string GetArgvZero() {
  const size_t kMaxModuleNameSize = kSbFileMaxName;
  std::vector<wchar_t> buffer(kMaxModuleNameSize);
  DWORD result = GetModuleFileName(NULL, buffer.data(), buffer.size());
  std::string arg;
  if (result == 0) {
    arg = "unknown";
  } else {
    arg = wchar_tToUTF8(buffer.data(), result).c_str();
  }
  return arg;
}

int MakeDeviceId() {
  // TODO: Devices MIGHT have colliding hashcodes. Some other unique int
  // ID generation tool would be better.
  using Windows::Security::ExchangeActiveSyncProvisioning::
      EasClientDeviceInformation;
  auto device_information = ref new EasClientDeviceInformation();
  Platform::String ^ device_id_string = device_information->Id.ToString();
  return device_id_string->GetHashCode();
}

#if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)

void SplitArgumentsIntoVector(std::string* args,
                              std::vector<std::string>* result) {
  SB_DCHECK(args);
  SB_DCHECK(result);
  while (!args->empty()) {
    size_t next = args->find(';');
    result->push_back(args->substr(0, next));
    if (next == std::string::npos) {
      return;
    }
    *args = args->substr(next + 1);
  }
}

// Parses a starboard: URI scheme by splitting args at ';' boundaries.
std::vector<std::string> ParseStarboardUri(const std::string& uri) {
  std::vector<std::string> result;
  result.push_back(GetArgvZero());

  size_t index = uri.find(':');
  if (index == std::string::npos) {
    return result;
  }

  std::string args = uri.substr(index + 1);
  SplitArgumentsIntoVector(&args, &result);

  return result;
}

void AddArgumentsFromFile(const char* path, std::vector<std::string>* args) {
  ScopedFile file(path, kSbFileOpenOnly | kSbFileRead);
  if (!file.IsValid()) {
    SB_LOG(INFO) << path << " is not valid for arguments.";
    return;
  }

  int64_t file_size = file.GetSize();
  if (file_size > kMaxArgumentFileSizeBytes) {
    SB_DLOG(ERROR) << "The arguments file is too big.";
    return;
  }

  if (file_size <= 0) {
    SB_DLOG(INFO) << "Arguments file is empty.";
    return;
  }

  std::string argument_string(file_size, '\0');
  int return_value = file.ReadAll(&argument_string[0], file_size);
  if (return_value < 0) {
    SB_DLOG(ERROR) << "Error while reading arguments from file.";
    return;
  }
  argument_string.resize(return_value);

  SplitArgumentsIntoVector(&argument_string, args);
}

void TryAddCommandArgsFromStarboardFile(std::vector<std::string>* args) {
  std::vector<char> content_directory(kSbFileMaxName);
  content_directory[0] = '\0';

  if (!SbSystemGetPath(kSbSystemPathContentDirectory, content_directory.data(),
                       content_directory.size())) {
    return;
  }

  std::string arguments_file_path(static_cast<char*>(content_directory.data()));
  arguments_file_path += kSbFileSepString;
  arguments_file_path += kStarboardArgumentsPath;

  AddArgumentsFromFile(arguments_file_path.c_str(), args);
}

void AddCommandArgsFromNetArgs(SbTime timeout, std::vector<std::string>* args) {
  // Detect if NetArgs is enabled for this run. If so then receive and
  // then merge the arguments into this run.
  SB_LOG(INFO) << "Waiting for net args...";
  std::vector<std::string> net_args = NetArgsWaitForPayload(timeout);
  if (!net_args.empty()) {
    std::stringstream ss;
    ss << "Found Net Args:\n";
    for (const std::string& s : net_args) {
      ss << "  " << s << "\n";
    }
    SB_LOG(INFO) << ss.str();
  }
  // Merge command arguments.
  args->insert(args->end(), net_args.begin(), net_args.end());
}

#endif  // defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)

std::unique_ptr<Application::Event> MakeDeepLinkEvent(
    const std::string& uri_string) {
  SB_LOG(INFO) << "Navigate to: [" << uri_string << "]";
  const size_t kMaxDeepLinkSize = 128 * 1024;
  const std::size_t uri_size = uri_string.size();
  if (uri_size > kMaxDeepLinkSize) {
    SB_NOTREACHED() << "App launch data too big: " << uri_size;
    return nullptr;
  }

  const int kBufferSize = static_cast<int>(uri_string.size()) + 1;
  char* deep_link = new char[kBufferSize];
  SB_DCHECK(deep_link);
  starboard::strlcpy(deep_link, uri_string.c_str(), kBufferSize);

  return std::unique_ptr<Application::Event>(
      new Application::Event(kSbEventTypeLink, deep_link,
                             Application::DeleteArrayDestructor<const char*>));
}

// Returns if |full_string| ends with |substring|.
bool ends_with(const std::string& full_string, const std::string& substring) {
  if (substring.length() > full_string.length()) {
    return false;
  }
  return std::equal(substring.rbegin(), substring.rend(), full_string.rbegin());
}

std::string GetBinaryName() {
  std::string full_binary_path = GetArgvZero();
  std::string::size_type index = full_binary_path.rfind(kSbFileSepChar);
  if (index == std::string::npos) {
    return full_binary_path;
  }

  return full_binary_path.substr(index + 1);
}

void OnDeviceAdded(DeviceWatcher ^, DeviceInformation ^) {
  SB_LOG(INFO) << "DisplayStatusWatcher::OnDeviceAdded";
  // We need delay to give time for the display initializing after connect.
  SbThreadSleep(15 * kSbTimeMillisecond);

  MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();

  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeUnfreeze, NULL, NULL));
  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeReveal, NULL, NULL));
  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeFocus, NULL, NULL));
}

void OnDeviceRemoved(DeviceWatcher ^, DeviceInformationUpdate ^) {
  // Without signing on OnDeviceRemoved, callback OnDeviceAdded doesn't work.
  SB_LOG(INFO) << "DisplayStatusWatcher::OnDeviceRemoved";

  MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();

  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeBlur, NULL, NULL));
  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeConceal, NULL, NULL));
  ApplicationUwp::Get()->Inject(
      new ApplicationUwp::Event(kSbEventTypeFreeze, NULL, NULL));
}

}  // namespace

namespace shared {
namespace win32 {
// Called into drm_system_playready.cc
extern void DrmSystemOnUwpResume();
}  // namespace win32
}  // namespace shared

ref class App sealed : public IFrameworkView {
 public:
  App(SbTimeMonotonic start_time)
      : application_start_time_{start_time},
        previously_activated_(false),
#if SB_API_VERSION >= 15
        application_(SbEventHandle),
#endif  // SB_API_VERSION >= 15
        is_online_(true) {
  }

  // IFrameworkView methods.
  virtual void Initialize(CoreApplicationView ^ application_view) {
    // The following incantation creates a DisplayRequest and obtains
    // its underlying COM interface.
    ComPtr<IInspectable> inspectable = reinterpret_cast<IInspectable*>(
        ref new Windows::System::Display::DisplayRequest());
    ComPtr<ABI::Windows::System::Display::IDisplayRequest> dr;
    inspectable.As(&dr);
    display_request = dr.Detach();

    SbAudioSinkPrivate::Initialize();
    Windows::Networking::Connectivity::NetworkInformation::
        NetworkStatusChanged += ref new Windows::Networking::Connectivity::
            NetworkStatusChangedEventHandler(this,
                                             &App::OnNetworkStatusChanged);
    CoreApplication::Suspending +=
        ref new EventHandler<SuspendingEventArgs ^>(this, &App::OnSuspending);
    CoreApplication::Resuming +=
        ref new EventHandler<Object ^>(this, &App::OnResuming);
    application_view->Activated +=
        ref new TypedEventHandler<CoreApplicationView ^, IActivatedEventArgs ^>(
            this, &App::OnActivated);

    MimeSupportabilityCache::GetInstance()->SetCacheEnabled(true);
    KeySystemSupportabilityCache::GetInstance()->SetCacheEnabled(true);
  }

  virtual void SetWindow(CoreWindow ^ window) {
    ApplicationUwp::Get()->SetCoreWindow(window);
    window->KeyUp += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(
        this, &App::OnKeyUp);
    window->KeyDown += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(
        this, &App::OnKeyDown);
  }

  virtual void Load(Platform::String ^ entry_point) {
    entry_point_ = wchar_tToUTF8(entry_point->Data());
  }

  virtual void Run() {
#if SB_API_VERSION >= 15
    main_return_value =
        SbRunStarboardMain(static_cast<int>(argv_.size()),
                           const_cast<char**>(argv_.data()), SbEventHandle);
#else
    main_return_value = application_.Run(static_cast<int>(argv_.size()),
                                         const_cast<char**>(argv_.data()));
#endif  // SB_API_VERSION >= 15
  }
  virtual void Uninitialize() {
    SbAudioSinkPrivate::TearDown();
    display_request->Release();
    display_request = nullptr;
  }

  void CompleteSuspendDeferral() {
    if (suspend_deferral_ != nullptr) {
      // Completing the deferral results in the app being suspended by the OS.
      SB_LOG(INFO) << "App is ready to be suspended.";
      suspend_deferral_->Complete();
      suspend_deferral_ = nullptr;
    }
  }

  void ExtendedExecutionSessionRevoked(Object ^ sender,
                                       ExtendedExecutionRevokedEventArgs ^
                                           args) {
    CompleteSuspendDeferral();
  }

  void ForceQuit() {
    SB_LOG(ERROR) << "Application is not safe to suspend, forcing exit.";
    ApplicationUwp::Get()->DispatchAndDelete(
        new ApplicationUwp::Event(kSbEventTypeStop, NULL, NULL));
    auto extended_resources_manager =
        shared::uwp::ExtendedResourcesManager::GetInstance();
    if (extended_resources_manager) {
      extended_resources_manager->Quit();
    }
  }

  void OnNetworkStatusChanged(Object ^ sender) {
    auto connection_profile = Windows::Networking::Connectivity::
        NetworkInformation::GetInternetConnectionProfile();
    bool is_online =
        connection_profile &&
        connection_profile->GetNetworkConnectivityLevel() !=
            Windows::Networking::Connectivity::NetworkConnectivityLevel::None;

    // Only inject event if the online status changed.
    if (is_online != is_online_) {
      auto* application = starboard::shared::starboard::Application::Get();

      // Verify we have an application and dispatcher before injecting events.
      if (application == nullptr) {
        SB_LOG(ERROR) << "OnNetworkStatusChanged has no application.";
        SB_DCHECK(false);
        return;
      }
      if (starboard::shared::uwp::GetDispatcher().Get() == nullptr) {
        SB_LOG(ERROR) << "OnNetworkStatusChanged has no dispatcher.";
        SB_DCHECK(false);
        return;
      }

      if (is_online) {
        application->InjectOsNetworkConnectedEvent();
      } else {
        application->InjectOsNetworkDisconnectedEvent();
      }
      is_online_ = is_online;
    }
  }

  void OnSuspending(Platform::Object ^ sender, SuspendingEventArgs ^ args) {
    // Request deferral of the suspending operation. This ensures that the app
    // does not immediately get suspended when this function returns.
    suspend_deferral_ = args->SuspendingOperation->GetDeferral();

    auto extended_resources_manager =
        shared::uwp::ExtendedResourcesManager::GetInstance();
    bool is_safe_to_suspend = extended_resources_manager->IsSafeToSuspend();

    // Request extended execution during which we will suspend the app and
    // release extended resources.
    auto session = ref new ExtendedExecutionSession();
    session->Reason = ExtendedExecutionReason::SavingData;
    session->Description = "Suspending...";

    // If the extended execution session gets revoked, we have to complete
    // the deferral.
    Windows::Foundation::EventRegistrationToken revoked_token =
        session->Revoked +=
        ref new TypedEventHandler<Object ^,
                                  ExtendedExecutionRevokedEventArgs ^>(
            this, &App::ExtendedExecutionSessionRevoked);
    Concurrency::create_task(session->RequestExtensionAsync())
        .then([this, is_safe_to_suspend,
               extended_resources_manager](ExtendedExecutionResult result) {
          // Suspend the app and release extended resources during the extended
          // session.

          // Note if we dispatch "suspend" here before pause, application.cc
          // will inject the "pause" which will cause us to go async which
          // will cause us to not have completed the suspend operation before
          // returning, which UWP requires.
          ApplicationUwp::Get()->DispatchAndDelete(
              new ApplicationUwp::Event(kSbEventTypeBlur, NULL, NULL));
          ApplicationUwp::Get()->DispatchAndDelete(
              new ApplicationUwp::Event(kSbEventTypeConceal, NULL, NULL));
          ApplicationUwp::Get()->DispatchAndDelete(
              new ApplicationUwp::Event(kSbEventTypeFreeze, NULL, NULL));
          extended_resources_manager->ReleaseExtendedResources();
          if (!extended_resources_manager->IsSafeToSuspend()) {
            ForceQuit();
          }
        })
        .then([this, is_safe_to_suspend, session, revoked_token]() {
          // The extended session has completed, we are ready to be suspended
          // now.
          session->Revoked -= revoked_token;
          delete session;

          CompleteSuspendDeferral();
        });
    if (!is_safe_to_suspend) {
      ForceQuit();
    }
  }

  void OnResuming(Platform::Object ^ sender, Platform::Object ^ args) {
    SB_LOG(INFO) << "Resuming application.";
    ApplicationUwp::Get()->DispatchAndDelete(
        new ApplicationUwp::Event(kSbEventTypeUnfreeze, NULL, NULL));
    ApplicationUwp::Get()->DispatchAndDelete(
        new ApplicationUwp::Event(kSbEventTypeReveal, NULL, NULL));
    ApplicationUwp::Get()->DispatchAndDelete(
        new ApplicationUwp::Event(kSbEventTypeFocus, NULL, NULL));
    shared::win32::DrmSystemOnUwpResume();
    shared::uwp::ExtendedResourcesManager::GetInstance()
        ->AcquireExtendedResources();
  }

  void OnKeyUp(CoreWindow ^ sender, KeyEventArgs ^ args) {
    ApplicationUwp::Get()->OnKeyEvent(sender, args, true);
  }

  void OnKeyDown(CoreWindow ^ sender, KeyEventArgs ^ args) {
    ApplicationUwp::Get()->OnKeyEvent(sender, args, false);
  }

  void OnActivated(CoreApplicationView ^ application_view,
                   IActivatedEventArgs ^ args) {
    SB_LOG(INFO) << "OnActivated";
    shared::uwp::ExtendedResourcesManager::GetInstance()
        ->AcquireExtendedResources();

    std::string start_url = entry_point_;
    bool command_line_set = false;

    // Please see application lifecycle description:
    // https://docs.microsoft.com/en-us/windows/uwp/launch-resume/app-lifecycle
    // Note that this document was written for Xaml apps not core apps,
    // so for us the precise API is a little different.
    // The substance is that, while OnActivated is definitely called the
    // first time the application is started, it may additionally called
    // in other cases while the process is already running. Starboard
    // applications cannot fully restart in a process lifecycle,
    // so we interpret the first activation and the subsequent ones differently.
    if (args->Kind == ActivationKind::Protocol) {
      Uri ^ uri = dynamic_cast<IProtocolActivatedEventArgs ^>(args)->Uri;

#if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
      // The starboard: scheme provides commandline arguments, but that's
      // only allowed during a process's first activation.
      std::string scheme = platformStringToString(uri->SchemeName);
      if (!previously_activated_ && ends_with(scheme, "-starboard")) {
        std::string uri_string = wchar_tToUTF8(uri->RawUri->Data());
        // args_ is a vector of std::string, but argv_ is a vector of
        // char* into args_ so as to compose a char**.
        args_ = ParseStarboardUri(uri_string);
        for (const std::string& arg : args_) {
          argv_.push_back(arg.c_str());
        }

        ApplicationUwp::Get()->SetCommandLine(static_cast<int>(argv_.size()),
                                              argv_.data());
        command_line_set = true;
      }
#endif  // defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
      if (uri->SchemeName->Equals("youtube") ||
          uri->SchemeName->Equals("youtube-tv") ||
          uri->SchemeName->Equals("ms-xbl-07459769")) {
        std::string uri_string = platformStringToString(uri->RawUri);

        // Strip the protocol from the uri.
        size_t index = uri_string.find(':');
        if (index != std::string::npos) {
          uri_string = uri_string.substr(index + 1);
        }

        ProcessDeepLinkUri(&uri_string);
      }
    } else if (args->Kind == ActivationKind::DialReceiver) {
      DialReceiverActivatedEventArgs ^ dial_args =
          dynamic_cast<DialReceiverActivatedEventArgs ^>(args);
      SB_CHECK(dial_args);
      Platform::String ^ arguments = dial_args->Arguments;
      if (previously_activated_) {
        std::string uri_string =
            kDialParamPrefix + platformStringToString(arguments);
        ProcessDeepLinkUri(&uri_string);
      } else {
        std::string activation_args = "--url=";
        activation_args.append(start_url);
        activation_args.append("?");
        activation_args.append(platformStringToString(arguments));
        SB_DLOG(INFO) << "Dial Activation url: " << activation_args;
        args_.push_back(GetArgvZero());
        args_.push_back(activation_args);
        // Set partition URL in case start_url is the main app first run
        // special case.
        std::string partition_arg = "--local_storage_partition_url=";
        partition_arg.append(entry_point_);
        args_.push_back(partition_arg);
        for (const std::string& arg : args_) {
          argv_.push_back(arg.c_str());
        }
        ApplicationUwp::Get()->SetCommandLine(static_cast<int>(argv_.size()),
                                              argv_.data());
        command_line_set = true;
      }
    }
    previous_activation_kind_ = args->Kind;

    if (!previously_activated_) {
      if (!command_line_set) {
#if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
        TryAddCommandArgsFromStarboardFile(&args_);
        CommandLine cmd_line(args_);
        if (cmd_line.HasSwitch(kNetArgsCommandSwitchWait)) {
          SbTime timeout = kSbTimeSecond * 2;
          std::string val = cmd_line.GetSwitchValue(kNetArgsCommandSwitchWait);
          if (!val.empty()) {
            timeout = atoi(val.c_str());
          }
          AddCommandArgsFromNetArgs(timeout, &args_);
        }
#endif  // defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)

        if (!CommandLine(args_).HasSwitch("url")) {
          args_.push_back(GetArgvZero());
          std::string start_url_arg = "--url=";
          start_url_arg.append(start_url);
          args_.push_back(start_url_arg);
          std::string partition_arg = "--local_storage_partition_url=";
          partition_arg.append(entry_point_);
          args_.push_back(partition_arg);
        }

        for (auto& arg : args_) {
          argv_.push_back(arg.c_str());
        }

        ApplicationUwp::Get()->SetCommandLine(static_cast<int>(argv_.size()),
                                              argv_.data());
      }

      ApplicationUwp* application_uwp = ApplicationUwp::Get();
      const CommandLine* command_line = application_uwp->GetCommandLine();

#if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
      if (command_line->HasSwitch(kWatchDogLog)) {
        // Launch a thread.
        std::string switch_val = command_line->GetSwitchValue(kWatchDogLog);
        auto uwp_dir =
            Windows::Storage::ApplicationData::Current->LocalCacheFolder;
        std::stringstream ss;
        ss << platformStringToString(uwp_dir->Path) << "/" << switch_val;
        shared::uwp::StartWatchdogLog(ss.str());
      }

      if (command_line->HasSwitch(kNetLogCommandSwitchWait)) {
        SbTime timeout = kSbTimeSecond;
        std::string val =
            command_line->GetSwitchValue(kNetLogCommandSwitchWait);
        if (!val.empty()) {
          timeout = atoi(val.c_str());
        }
        NetLogWaitForClientConnected(timeout);
      }

      if (command_line->HasSwitch(kLogPathSwitch)) {
        std::stringstream ss;
        ss << platformStringToString(
            Windows::Storage::ApplicationData::Current->LocalCacheFolder->Path);
        ss << "\\"
           << "" << command_line->GetSwitchValue(kLogPathSwitch);
        std::string full_path_log_file = ss.str();
        shared::uwp::OpenLogFileWin32(full_path_log_file.c_str());
      } else {
#if !defined(COBALT_BUILD_TYPE_GOLD)
        // Log to a file on the last removable device available (probably the
        // most recently added removable device).
        if (KnownFolders::RemovableDevices != nullptr) {
          concurrency::create_task(
              KnownFolders::RemovableDevices->GetFoldersAsync())
              .then(
                  [](concurrency::task<IVectorView<StorageFolder ^> ^> result) {
                    IVectorView<StorageFolder ^> ^ results;
                    try {
                      results = result.get();
                    } catch (Platform::Exception ^) {
                      SB_LOG(ERROR)
                          << "Unable to open log file in RemovableDevices";
                      return;
                    }

                    if (results->Size == 0) {
                      return;
                    }

                    StorageFolder ^ folder = results->GetAt(results->Size - 1);
                    Calendar ^ now = ref new Calendar();
                    char filename[128];
                    SbStringFormatF(filename, sizeof(filename),
                                    "cobalt_log_%04d%02d%02d_%02d%02d%02d.txt",
                                    now->Year, now->Month, now->Day,
                                    now->Hour + now->FirstHourInThisPeriod,
                                    now->Minute, now->Second);
                    shared::uwp::OpenLogFileUWP(folder, filename);
                  });
        }
#endif  // !defined(COBALT_BUILD_TYPE_GOLD)
      }
#endif  // defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
      SB_LOG(INFO) << "Starting " << GetBinaryName();

      CoreWindow::GetForCurrentThread()->Activate();
      // Call DispatchStart async so the UWP system thinks we're activated.
      // Some tools seem to want the application to be activated before
      // interacting with them, some things are disallowed during activation
      // (such as exiting), and DispatchStart (for example) runs
      // automated tests synchronously.
      RunInMainThreadAsync([this]() {
        ApplicationUwp::Get()->DispatchStart(application_start_time_);
      });
    }
    previously_activated_ = true;
  }

 private:
  void ProcessDeepLinkUri(std::string* uri_string) {
    SB_DCHECK(uri_string);
    if (previously_activated_) {
      std::unique_ptr<Application::Event> event =
          MakeDeepLinkEvent(*uri_string);
      SB_DCHECK(event);
      ApplicationUwp::Get()->Inject(event.release());
    } else {
      ApplicationUwp::Get()->SetStartLink(uri_string->c_str());
    }
  }

  std::string entry_point_;
  bool is_online_;
  bool previously_activated_;
  // Only valid if previously_activated_ is true
  ActivationKind previous_activation_kind_;
  std::vector<std::string> args_;
  std::vector<const char*> argv_;

  shared::uwp::ApplicationUwp application_;
  SuspendingDeferral ^ suspend_deferral_ = nullptr;
  SbTimeMonotonic application_start_time_;
};

ref class Direct3DApplicationSource sealed : IFrameworkViewSource {
 public:
  Direct3DApplicationSource(SbTimeMonotonic start_time)
      : application_start_time_{start_time} {}
  virtual IFrameworkView ^ CreateView() {
    return ref new App(application_start_time_);
  } private : SbTimeMonotonic application_start_time_;
};

namespace shared {
namespace uwp {

void DisplayStatusWatcher::CreateWatcher() {
  Platform::Collections::Vector<Platform::String ^> ^ requestedProperties =
      ref new Platform::Collections::Vector<Platform::String ^>();
  requestedProperties->Append("System.Devices.InterfaceClassGuid");
  requestedProperties->Append("System.ItemNameDisplay");
  watcher_ = DeviceInformation::CreateWatcher(
      const_cast<Platform::String ^>(kGenericPnpMonitorAqs),
      requestedProperties);
  SB_CHECK(watcher_);
  watcher_->Added +=
      ref new TypedEventHandler<DeviceWatcher ^, DeviceInformation ^>(
          &OnDeviceAdded);
  watcher_->Removed +=
      ref new TypedEventHandler<DeviceWatcher ^, DeviceInformationUpdate ^>(
          &OnDeviceRemoved);
  watcher_->Start();
}

bool DisplayStatusWatcher::IsWatcherStarted() {
  SB_CHECK(watcher_);
  DeviceWatcherStatus status = watcher_->Status;
  return (status == DeviceWatcherStatus::Started) ||
         (status == DeviceWatcherStatus::EnumerationCompleted);
}

void DisplayStatusWatcher::StopWatcher() {
  SB_CHECK(watcher_);
  if (IsWatcherStarted()) {
    watcher_->Stop();
  }
}

#if SB_API_VERSION >= 15
ApplicationUwp::ApplicationUwp(SbEventHandleCallback sb_event_handle_callback)
    : shared::starboard::Application(sb_event_handle_callback),
      window_(kSbWindowInvalid),
#else
ApplicationUwp::ApplicationUwp()
    : window_(kSbWindowInvalid),
#endif  // SB_API_VERSION >= 15
      localized_strings_(SbSystemGetLocaleId()),
      device_id_(MakeDeviceId()) {
  SbWindowOptions options;
  SbWindowSetDefaultOptions(&options);
  window_size_ = options.size;
  analog_thumbstick_thread_.reset(new AnalogThumbstickThread(this));
}

ApplicationUwp::~ApplicationUwp() {
  SB_CHECK(watcher_);
  {
    ScopedLock lock(time_event_mutex_);
    timer_event_map_.clear();
  }
  watcher_->StopWatcher();
  analog_thumbstick_thread_.reset(nullptr);
}

void ApplicationUwp::Initialize() {}

void ApplicationUwp::Teardown() {
  CloseWatchdogLog();
}

Application::Event* ApplicationUwp::GetNextEvent() {
  SB_NOTREACHED();
  return nullptr;
}

SbWindow ApplicationUwp::CreateWindowForUWP(const SbWindowOptions*) {
  // TODO: Determine why SB_DCHECK(IsCurrentThread()) fails in nplb, fix it,
  // and add back this check.

  if (SbWindowIsValid(window_)) {
    return kSbWindowInvalid;
  }

  if (!watcher_) {
    watcher_ = ref new shared::uwp::DisplayStatusWatcher();
    watcher_->CreateWatcher();
  }

  window_size_ = GetPreferredWindowSize();

  window_ = new SbWindowPrivate(window_size_.width, window_size_.height);
  return window_;
}

SbWindowSize ApplicationUwp::GetVisibleAreaSize() {
  SbWindowSize size{};
  if (SbWindowGetSize(window_, &size)) {
    return size;
  }
  return window_size_;
}

SbWindowSize ApplicationUwp::GetPreferredWindowSize() {
  bool scale_enabled = true;
  if (ApiInformation::IsApiContractPresent(
          "Windows.UI.ViewManagement.ViewManagementViewScalingContract", 1)) {
    // Use unscaled layout where possible
    scale_enabled = !ApplicationViewScaling::TrySetDisableLayoutScaling(true);
  }

  auto app_view = ApplicationView::GetForCurrentView();
  bool is_fullscreen = app_view->IsFullScreenMode;

  if (!is_fullscreen && scale_enabled &&
      ApiInformation::IsApiContractPresent(
          "Windows.Xbox.ApplicationResourcesContract", 1)) {
    // Always use full screen mode for XBox
    is_fullscreen = app_view->TryEnterFullScreenMode();
  }

  UpdateDisplayPreferredMode();
  int width = 0;
  int height = 0;
  auto display_mode = ApplicationUwp::Get()->GetPreferredModeHdr();
  if (!display_mode) {
    display_mode = ApplicationUwp::Get()->GetPreferredModeHdmi();
  }
  if (display_mode) {
    width = display_mode->ResolutionWidthInRawPixels;
    height = display_mode->ResolutionHeightInRawPixels;
  } else {
    auto bounds = app_view->VisibleBounds;
    auto scaleFactor =
        DisplayInformation::GetForCurrentView()->RawPixelsPerViewPixel;
    width = bounds.Width * scaleFactor;
    height = bounds.Height * scaleFactor;
  }
  SB_LOG(INFO) << "Preferred window size is " << width << " x " << height
               << "\nScaling is " << (scale_enabled ? "enabled" : "disabled")
               << "\nFull Screen mode is " << (is_fullscreen ? "ON" : "OFF");

  return SbWindowSize{width, height};
}

bool ApplicationUwp::DestroyWindow(SbWindow window) {
  // TODO: Determine why SB_DCHECK(IsCurrentThread()) fails in nplb, fix it,
  // and add back this check.

  if (!SbWindowIsValid(window)) {
    SB_DLOG(ERROR) << __FUNCTION__ << ": Invalid context.";
    return false;
  }

  auto app_view = ApplicationView::GetForCurrentView();
  if (app_view->IsFullScreenMode &&
      ApiInformation::IsApiContractPresent(
          "Windows.Xbox.ApplicationResourcesContract", 1)) {
    app_view->ExitFullScreenMode();
  }

  SB_DCHECK(window_ == window);
  delete window;
  window_ = kSbWindowInvalid;

  return true;
}

void ApplicationUwp::UpdateDisplayPreferredMode() {
  ScopedLock lock(preferred_display_mode_mutex_);
  preferred_display_mode_hdmi_ = nullptr;
  preferred_display_mode_hdr_ = nullptr;
  if (!ApiInformation::IsTypePresent(
          "Windows.Graphics.Display.Core.HdmiDisplayInformation")) {
    return;
  }

  auto hdmi_display_info = HdmiDisplayInformation::GetForCurrentView();
  if (!hdmi_display_info) {
    return;
  }

  preferred_display_mode_hdmi_ = hdmi_display_info->GetCurrentDisplayMode();
  for (auto mode : hdmi_display_info->GetSupportedDisplayModes()) {
    if (mode->ResolutionWidthInRawPixels ==
            preferred_display_mode_hdmi_->ResolutionWidthInRawPixels &&
        mode->ResolutionHeightInRawPixels ==
            preferred_display_mode_hdmi_->ResolutionHeightInRawPixels &&
        mode->Is2086MetadataSupported && mode->IsSmpte2084Supported &&
        mode->BitsPerPixel >= kYuv420BitsPerPixelForHdr10Mode &&
        mode->ColorSpace == HdmiDisplayColorSpace::BT2020) {
      if (!preferred_display_mode_hdr_ ||
          preferred_display_mode_hdr_->RefreshRate < mode->RefreshRate) {
        preferred_display_mode_hdr_ = mode;
      }
    }
  }
}

bool ApplicationUwp::DispatchNextEvent() {
  core_window_->Activate();
  core_window_->Dispatcher->ProcessEvents(
      CoreProcessEventsOption::ProcessUntilQuit);
  return false;
}

Windows::Media::Protection::HdcpSession ^ ApplicationUwp::GetHdcpSession() {
  if (!hdcp_session_) {
    hdcp_session_ = ref new HdcpSession();
  }
  return hdcp_session_;
}

void ApplicationUwp::ResetHdcpSession() {
  // delete will call the destructor, but not free memory.
  // The destructor is called explicitly so that HDCP session can be
  // torn down immediately.
  if (hdcp_session_) {
    delete hdcp_session_;
    hdcp_session_ = nullptr;
  }
}

void ApplicationUwp::Inject(Application::Event* event) {
  RunInMainThreadAsync([this, event]() {
    bool result = DispatchAndDelete(event);
    if (!result) {
      NetLogFlushThenClose();
      CoreApplication::Exit();
    }
  });
}

void ApplicationUwp::InjectKeypress(SbKey key) {
  if (!SbWindowIsValid(window_)) {
    return;
  }
  std::unique_ptr<SbInputData> press_data(new SbInputData());
  std::unique_ptr<SbInputData> unpress_data(new SbInputData());

  memset(press_data.get(), 0, sizeof(*press_data));
  press_data->window = window_;
  press_data->device_type = kSbInputDeviceTypeKeyboard;
  press_data->device_id = device_id();
  press_data->key = key;
  press_data->type = kSbInputEventTypePress;

  *unpress_data = *press_data;
  unpress_data->type = kSbInputEventTypeUnpress;

  Inject(new Event(kSbEventTypeInput, press_data.release(),
                   &Application::DeleteDestructor<SbInputData>));
  Inject(new Event(kSbEventTypeInput, unpress_data.release(),
                   &Application::DeleteDestructor<SbInputData>));
}

void ApplicationUwp::InjectTimedEvent(Application::TimedEvent* timed_event) {
  SbTimeMonotonic delay_usec =
      timed_event->target_time - SbTimeGetMonotonicNow();
  if (delay_usec < 0) {
    delay_usec = 0;
  }

  // TimeSpan ticks are, like FILETIME, 100ns
  const SbTimeMonotonic kTicksPerUsec = 10;

  TimeSpan timespan;
  timespan.Duration = delay_usec * kTicksPerUsec;

  ScopedLock lock(time_event_mutex_);
  ThreadPoolTimer ^ timer = ThreadPoolTimer::CreateTimer(
      ref new TimerElapsedHandler([this, timed_event](ThreadPoolTimer ^ timer) {
        RunInMainThreadAsync([this, timed_event]() {
          // Even if the event is canceled, the callback can still fire.
          // Thus, the existence of event in timer_event_map_ is used
          // as a source of truth.
          std::size_t number_erased = 0;
          {
            ScopedLock lock(time_event_mutex_);
            number_erased = timer_event_map_.erase(timed_event->id);
          }
          if (number_erased > 0) {
            timed_event->callback(timed_event->context);
          }
        });
      }),
      timespan);
  timer_event_map_.emplace(timed_event->id, timer);
}

void ApplicationUwp::CancelTimedEvent(SbEventId event_id) {
  ScopedLock lock(time_event_mutex_);
  auto it = timer_event_map_.find(event_id);
  if (it == timer_event_map_.end()) {
    return;
  }
  it->second->Cancel();
  timer_event_map_.erase(it);
}

Application::TimedEvent* ApplicationUwp::GetNextDueTimedEvent() {
  SB_NOTIMPLEMENTED();
  return nullptr;
}

SbTimeMonotonic ApplicationUwp::GetNextTimedEventTargetTime() {
  SB_NOTIMPLEMENTED();
  return 0;
}

void ApplicationUwp::OnJoystickUpdate(SbKey key, SbInputVector input_vector) {
  if (!SbWindowIsValid(window_)) {
    return;
  }
  scoped_ptr<SbInputData> data(new SbInputData());
  memset(data.get(), 0, sizeof(*data));
  data->window = window_;
  data->type = kSbInputEventTypeMove;
  data->device_type = kSbInputDeviceTypeGamepad;
  data->device_id = device_id();
  data->key = key;
  data->character = 0;

  data->key_modifiers = kSbKeyModifiersNone;
  data->position = input_vector;

  SbKeyLocation key_location = kSbKeyLocationUnspecified;
  switch (key) {
    case kSbKeyGamepadLeftStickLeft:
    case kSbKeyGamepadLeftStickUp: {
      key_location = kSbKeyLocationLeft;
      break;
    }
    case kSbKeyGamepadRightStickLeft:
    case kSbKeyGamepadRightStickUp: {
      key_location = kSbKeyLocationRight;
      break;
    }
    default: {
      SB_NOTREACHED();
      break;
    }
  }

  data->key_location = key_location;
  Inject(new Event(kSbEventTypeInput, data.release(),
                   &Application::DeleteDestructor<SbInputData>));
}

Platform::String ^
    ApplicationUwp::GetString(const char* id, const char* fallback) const {
  return stringToPlatformString(localized_strings_.GetString(id, fallback));
}

bool ApplicationUwp::IsHdcpOn() {
  ScopedLock lock(hdcp_session_mutex_);

  return GetHdcpSession()->IsEffectiveProtectionAtLeast(kHDCPProtectionMode);
}

bool ApplicationUwp::TurnOnHdcp() {
  HdcpSetProtectionResult protection_result;
  {
    ScopedLock lock(hdcp_session_mutex_);

    protection_result = WaitForResult(
        GetHdcpSession()->SetDesiredMinProtectionAsync(kHDCPProtectionMode));
  }

  if (IsHdcpOn()) {
    return true;
  }

  // If the operation did not have intended result, log something.
  switch (protection_result) {
    case HdcpSetProtectionResult::Success:
      SB_LOG(INFO) << "Successfully set HDCP.";
      break;
    case HdcpSetProtectionResult::NotSupported:
      SB_LOG(INFO) << "HDCP is not supported.";
      break;
    case HdcpSetProtectionResult::TimedOut:
      SB_LOG(INFO) << "Setting HDCP timed out.";
      break;
    case HdcpSetProtectionResult::UnknownFailure:
      SB_LOG(INFO) << "Unknown failure returned while setting HDCP.";
      break;
  }

  return false;
}

bool ApplicationUwp::TurnOffHdcp() {
  {
    ScopedLock lock(hdcp_session_mutex_);
    ResetHdcpSession();
  }
  bool success = !IsHdcpOn();
  return success;
}

// TODO: Consolidate this function with TurnOfHdcp() and TurnOffHdcp().
bool ApplicationUwp::SetOutputProtection(bool should_enable_dhcp) {
  bool is_hdcp_on = IsHdcpOn();

  if (is_hdcp_on == should_enable_dhcp) {
    return true;
  }

  SB_LOG(INFO) << "Attempting to "
               << (should_enable_dhcp ? "enable" : "disable")
               << " output protection.  Current status: "
               << (is_hdcp_on ? "enabled" : "disabled");
  SbTimeMonotonic tick = SbTimeGetMonotonicNow();

  bool hdcp_success = false;
  if (should_enable_dhcp) {
    hdcp_success = TurnOnHdcp();
  } else {
    hdcp_success = TurnOffHdcp();
  }

  is_hdcp_on = (hdcp_success ? should_enable_dhcp : !should_enable_dhcp);

  SbTimeMonotonic tock = SbTimeGetMonotonicNow();
  SB_LOG(INFO) << "Output protection is "
               << (is_hdcp_on ? "enabled" : "disabled")
               << ".  Toggling HDCP took " << (tock - tick) / kSbTimeMillisecond
               << " milliseconds.";
  return hdcp_success;
}

Platform::Agile<Windows::UI::Core::CoreDispatcher> GetDispatcher() {
  return ApplicationUwp::Get()->GetDispatcher();
}

Platform::Agile<Windows::Media::SystemMediaTransportControls>
GetTransportControls() {
  return ApplicationUwp::Get()->GetTransportControls();
}

void DisplayRequestActive() {
  RunInMainThreadAsync([]() {
    if (display_request != nullptr) {
      display_request->RequestActive();
    }
  });
}

void DisplayRequestRelease() {
  RunInMainThreadAsync([]() {
    if (display_request != nullptr) {
      display_request->RequestRelease();
    }
  });
}

void InjectKeypress(SbKey key) {
  ApplicationUwp::Get()->InjectKeypress(key);
}

namespace {

// Calls CoreApplication::Run() on a new thread to free up the main thread.
// This allows all extended resources related operations to be run on the main
// thread.
class CoreApplicationThread : public ::starboard::Thread {
 public:
  explicit CoreApplicationThread(SbTimeMonotonic start_time)
      : application_start_time_{start_time}, Thread("core_app") {}
  void Run() override {
    CoreApplication::Run(
        ref new Direct3DApplicationSource(application_start_time_));
    ExtendedResourcesManager::GetInstance()->Quit();
  }

 private:
  SbTimeMonotonic application_start_time_;
};

}  // namespace

int InternalMain() {
  volatile auto start_time = SbTimeGetMonotonicNow();
  if (!IsDebuggerPresent()) {
    // By default, a Windows application will display a dialog box
    // when it crashes. This is extremely undesirable when run offline.
    // The following configures messages to be print to the console instead.
    _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
    _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
    _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
    _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
  }

  WSAData wsaData;
  int init_result = WSAStartup(
      MAKEWORD(kWinSockVersionMajor, kWinSockVersionMajor), &wsaData);

  SB_CHECK(init_result == 0);
  // WSAStartup returns the highest version that is supported up to the version
  // we request.
  SB_CHECK(LOBYTE(wsaData.wVersion) == kWinSockVersionMajor &&
           HIBYTE(wsaData.wVersion) == kWinSockVersionMinor);

  HRESULT hr = MFStartup(MF_VERSION);
  SB_DCHECK(SUCCEEDED(hr));

#if defined(COBALT_BUILD_TYPE_GOLD)
  // Early exit for gold builds on desktop as a security measure.
#if SB_API_VERSION < 15
  if (SbSystemGetDeviceType() == kSbSystemDeviceTypeDesktopPC) {
    return main_return_value;
  }
#else
  if (GetSystemPropertyString(kSbSystemPropertyDeviceType) ==
      kSystemDeviceTypeDesktopPC) {
    return main_return_value;
  }
#endif
#endif  // defined(COBALT_BUILD_TYPE_GOLD)

  shared::win32::RegisterMainThread();

  ExtendedResourcesManager extended_resources_manager;
  CoreApplicationThread thread(start_time);

  thread.Start();
  extended_resources_manager.Run();

  NetLogFlushThenClose();
  CoreApplication::Exit();

  MFShutdown();
  WSACleanup();

  return main_return_value;
}

#if SB_API_VERSION >= 15
extern "C" int SbRunStarboardMain(int argc,
                                  char** argv,
                                  SbEventHandleCallback callback) {
  return ApplicationUwp::Get()->Run(argc, argv);
}
#endif  // SB_API_VERSION >= 15

}  // namespace uwp
}  // namespace shared
}  // namespace starboard

[Platform::MTAThread] int main(Platform::Array<Platform::String ^> ^ args) {
  return starboard::shared::uwp::InternalMain();
}