Third part of porting Chrome Ash to Windows 7

win8/metro_driver/metro_driver_win7.cc

 // Copyright (c) 2012 The Chromium Authors. 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 <corewindow.h>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 
 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
+int g_window_count = 0;
 
 LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                          WPARAM wparam, LPARAM lparam) {
   PAINTSTRUCT ps;
   HDC hdc;
   switch (message) {

[ananta, 2014/04/11 02:25:24]

Please add some comments here about why we need the g_window_count variable.

+    case WM_CREATE:
+      ++g_window_count;
+      break;
     case WM_PAINT:
       hdc = ::BeginPaint(hwnd, &ps);
       EndPaint(hwnd, &ps);
       break;
-    case WM_LBUTTONUP:
-      //  TODO(cpu): Remove this test code.
-      ::InvalidateRect(hwnd, NULL, TRUE);
+    case WM_CLOSE:
+      DestroyWindow(hwnd);
       break;
     case WM_DESTROY:
-      PostQuitMessage(0);
+      --g_window_count;
+      if (!g_window_count)
+        PostQuitMessage(0);
       break;
     default:
       return ::DefWindowProc(hwnd, message, wparam, lparam);
   }
   return 0;
 }
 
 HWND CreateMetroTopLevelWindow() {
   HINSTANCE hInst = reinterpret_cast<HINSTANCE>(&__ImageBase);
   WNDCLASSEXW wcex;
   wcex.cbSize = sizeof(wcex);
   wcex.style              = CS_HREDRAW | CS_VREDRAW;
   wcex.lpfnWndProc        = WndProc;
   wcex.cbClsExtra         = 0;
   wcex.cbWndExtra         = 0;
   wcex.hInstance          = hInst;
   wcex.hIcon              = 0;
   wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
   wcex.hbrBackground      = (HBRUSH)(COLOR_INACTIVECAPTION+1);
   wcex.lpszMenuName       = 0;
   wcex.lpszClassName      = L"Windows.UI.Core.CoreWindow";
   wcex.hIconSm            = 0;
 
   HWND hwnd = ::CreateWindowExW(0,
                                 MAKEINTATOM(::RegisterClassExW(&wcex)),
                                 L"metro_win7",
                                 WS_POPUP | WS_VISIBLE,
-                                0, 0, 1024, 1024,
+                                0, 0, 1600, 900,
                                 NULL, NULL, hInst, NULL);
   return hwnd;
 }
 
 typedef winfoundtn::ITypedEventHandler<
     winapp::Core::CoreApplicationView*,
     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
@@ skipping 74 matching lines @@
   }
 
   virtual HRESULT STDMETHODCALLTYPE ProcessEvents(
       winui::Core::CoreProcessEventsOption options) {
     // We don't support the other message pump modes. So we basically enter a
     // traditional message loop that we only exit a teardown.
     if (options != winui::Core::CoreProcessEventsOption_ProcessUntilQuit)
       return E_FAIL;
 
     MSG msg = {0};
-    while(::GetMessage(&msg, NULL, 0, 0) != 0) {
+    while((::GetMessage(&msg, NULL, 0, 0) != 0) && g_window_count > 0) {
       ::TranslateMessage(&msg);
       ::DispatchMessage(&msg);
     }
     // TODO(cpu): figure what to do with msg.WParam which we would normally
     // return here.
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE RunAsync(
       winui::Core::CoreDispatcherPriority priority,
@@ skipping 27 matching lines @@
     : public mswr::RuntimeClass<
         mswr::RuntimeClassFlags<mswr::WinRtClassicComMix>,
         winui::Core::ICoreWindow, ICoreWindowInterop> {
  public:
   CoreWindowEmulation() : core_hwnd_(NULL) {
     dispatcher_ = mswr::Make<CoreDispacherEmulation>();
     core_hwnd_ = CreateMetroTopLevelWindow();
   }
 
   ~CoreWindowEmulation() {
-    ::DestroyWindow(core_hwnd_);
+    if (core_hwnd_)
+      ::DestroyWindow(core_hwnd_);
   }
 
   // ICoreWindow implementation:
   virtual HRESULT STDMETHODCALLTYPE get_AutomationHostProvider(
       IInspectable** value) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE get_Bounds(
       winfoundtn::Rect* value) {
@@ skipping 54 matching lines @@
       boolean* value) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE Activate(void) {
     // After we fire OnActivate on the View, Chrome calls us back here.
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE Close(void) {
+    ::PostMessage(core_hwnd_, WM_CLOSE, 0, 0);
+    core_hwnd_ = NULL;
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE GetAsyncKeyState(
       ABI::Windows::System::VirtualKey virtualKey,
       winui::Core::CoreVirtualKeyStates* KeyState) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE GetKeyState(
@@ skipping 253 matching lines @@
 
 class CoreApplicationViewEmulation
     : public mswr::RuntimeClass<winapp::Core::ICoreApplicationView> {
  public:
    CoreApplicationViewEmulation() {
       core_window_ = mswr::Make<CoreWindowEmulation>();
    }
 
   HRESULT Activate() {
     if (activated_handler_) {
+      // This form means chrome or a test has launched the viewer.
+      if (CommandLine::ForCurrentProcess()->HasSwitch("connect"))
+        return activated_handler_->Invoke(this, nullptr);
+      // This form used to reach other integration code paths.
       auto ae = mswr::Make<ActivatedEvent>(
         winapp::Activation::ActivationKind_File);
       return activated_handler_->Invoke(this, ae.Get());
     } else {
       return S_OK;
     }
   }
 
+  HRESULT Close() {
+    return core_window_->Close();
+  }
+
   // ICoreApplicationView implementation:
   virtual HRESULT STDMETHODCALLTYPE get_CoreWindow(
     winui::Core::ICoreWindow** value) {
     if (!core_window_)
       return E_FAIL;
     return core_window_.CopyTo(value);
   }
 
   virtual HRESULT STDMETHODCALLTYPE add_Activated(
      ActivatedHandler* handler,
@@ skipping 15 matching lines @@
     boolean* value) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE get_IsHosted(
     boolean* value) {
     return S_OK;
   }
 
  private:
-  mswr::ComPtr<winui::Core::ICoreWindow> core_window_;
+  mswr::ComPtr<CoreWindowEmulation> core_window_;
   mswr::ComPtr<ActivatedHandler> activated_handler_;
 };
 
 class CoreApplicationWin7Emulation
     : public mswr::RuntimeClass<winapp::Core::ICoreApplication,
                                 winapp::Core::ICoreApplicationExit> {
  public:
    // ICoreApplication implementation:
 
   virtual HRESULT STDMETHODCALLTYPE get_Id(
@@ skipping 58 matching lines @@
     return app_view_->Run();
   }
 
   virtual HRESULT STDMETHODCALLTYPE RunWithActivationFactories(
       winfoundtn::IGetActivationFactory* activationFactoryCallback) {
     return S_OK;
   }
 
   // ICoreApplicationExit implementation:
 
-  virtual HRESULT STDMETHODCALLTYPE Exit(void) {
-    return S_OK;
+  virtual HRESULT STDMETHODCALLTYPE Exit() {
+    return view_emulation_->Close();
   }
 
   virtual HRESULT STDMETHODCALLTYPE add_Exiting(
        winfoundtn::IEventHandler<IInspectable*>* handler,
       EventRegistrationToken* token) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE remove_Exiting(
       EventRegistrationToken token) {
     return S_OK;
   }
 
  private:
   mswr::ComPtr<winapp::Core::IFrameworkView> app_view_;
   mswr::ComPtr<CoreApplicationViewEmulation> view_emulation_;
 };
 
 
 mswr::ComPtr<winapp::Core::ICoreApplication> InitWindows7() {
   HRESULT hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
   if (FAILED(hr))
     CHECK(false);
   return mswr::Make<CoreApplicationWin7Emulation>();
 }