Notify the Chrome browser process about the window being activated from the viewer process.

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 <shobjidl.h>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/win/msg_util.h"
 
 #pragma comment(lib, "shell32.lib")
 
 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
 // Even though we only create a single window, we need to keep this
 // count because of the hidden window used by the UI message loop of
 // the metro viewer.
 int g_window_count = 0;
 
 const wchar_t kAshWin7AppId[] = L"Google.Chrome.AshWin7.1";
-
+const wchar_t kAshWin7CoreWindowHandler[] = L"CoreWindowHandler";
 extern float GetModernUIScale();
-
-LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
-                         WPARAM wparam, LPARAM lparam) {
-  PAINTSTRUCT ps;
-  HDC hdc;
-  switch (message) {
-    case WM_CREATE:
-      ++g_window_count;
-      break;
-    case WM_PAINT:
-      hdc = ::BeginPaint(hwnd, &ps);
-      ::EndPaint(hwnd, &ps);
-      break;
-    case WM_CLOSE:
-      ::DestroyWindow(hwnd);
-      break;
-    case WM_DESTROY:
-      --g_window_count;
-      if (!g_window_count)
-        ::PostQuitMessage(0);
-      break;
-    // Always allow Chrome to set the cursor.
-    case WM_SETCURSOR:
-      return 1;
-    default:
-      return ::DefWindowProc(hwnd, message, wparam, lparam);
-  }
-  return 0;
-}
+LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam,
+                         LPARAM lparam);
 
 HWND CreateMetroTopLevelWindow(const RECT& work_area) {
   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              = LoadIcon(::GetModuleHandle(NULL), L"IDR_MAINFRAME");
   wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
   wcex.hbrBackground      = (HBRUSH)(COLOR_INACTIVECAPTION+1);
   wcex.lpszMenuName       = 0;
   wcex.lpszClassName      = L"Windows.UI.Core.CoreWindow";
   wcex.hIconSm            = LoadIcon(::GetModuleHandle(NULL), L"IDR_MAINFRAME");
 
-
-
   HWND hwnd = ::CreateWindowExW(0,
                                 MAKEINTATOM(::RegisterClassExW(&wcex)),
                                 L"metro_win7",
                                 WS_POPUP | WS_VISIBLE | WS_MINIMIZEBOX,
                                 work_area.top, work_area.left,
                                 work_area.right, work_area.bottom,
                                 NULL, NULL, hInst, NULL);
   return hwnd;
 }
 
@@ skipping 475 matching lines @@
   InputHandler* input_handler_;
   AcceleratorKeyEventHandler* accelerator_key_event_handler_;
 };
 
 class CoreWindowEmulation
     : public mswr::RuntimeClass<
         mswr::RuntimeClassFlags<mswr::WinRtClassicComMix>,
         winui::Core::ICoreWindow, ICoreWindowInterop>,
       public InputHandler {
  public:
-  CoreWindowEmulation()
+  CoreWindowEmulation(winapp::Core::IFrameworkView* app_view)
       : core_hwnd_(NULL),
         mouse_moved_handler_(NULL),
         mouse_capture_lost_handler_(NULL),
         mouse_pressed_handler_(NULL),
         mouse_released_handler_(NULL),
         mouse_entered_handler_(NULL),
         mouse_exited_handler_(NULL),
         mouse_wheel_changed_handler_(NULL),
         key_down_handler_(NULL),
         key_up_handler_(NULL),
-        character_received_handler_(NULL) {
+        character_received_handler_(NULL),
+        app_view_(app_view),
+        window_activated_handler_(NULL) {
     dispatcher_ = mswr::Make<CoreDispatcherEmulation>(this);
 
     // Unless we select our own AppUserModelID the shell might confuse us
     // with the app launcher one and we get the wrong taskbar button and icon.
     ::SetCurrentProcessExplicitAppUserModelID(kAshWin7AppId);
 
     RECT work_area = {0};
     ::SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
     if (::IsDebuggerPresent()) {
       work_area.top = 0;
       work_area.left = 0;
       work_area.right = 1600;
       work_area.bottom = 900;
     }
 
     core_hwnd_ = CreateMetroTopLevelWindow(work_area);
+    ::SetProp(core_hwnd_, kAshWin7CoreWindowHandler, this);
   }
 
   ~CoreWindowEmulation() {
-    if (core_hwnd_)
+    if (core_hwnd_) {
+      ::RemoveProp(core_hwnd_, kAshWin7CoreWindowHandler);
       ::DestroyWindow(core_hwnd_);
+    }
   }
 
   // ICoreWindow implementation:
   virtual HRESULT STDMETHODCALLTYPE get_AutomationHostProvider(
       IInspectable** value) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE get_Bounds(
       winfoundtn::Rect* value) {
@@ skipping 82 matching lines @@
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE SetPointerCapture(void) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE add_Activated(
       WindowActivatedHandler* handler,
       EventRegistrationToken* pCookie) {
-    // TODO(cpu) implement this.
+    window_activated_handler_ = handler;
+    handler->AddRef();
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE remove_Activated(
       EventRegistrationToken cookie) {
+    window_activated_handler_->Release();
+    window_activated_handler_ = NULL;
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE add_AutomationProviderRequested(
       AutomationProviderHandler* handler,
       EventRegistrationToken* cookie) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE remove_AutomationProviderRequested(
@@ skipping 276 matching lines @@
       }
 
       default:
         return false;
     }
     DCHECK(handler);
     handler->Invoke(this, event_args.Get());
     return true;
   }
 
+  void OnWindowActivated() {
+    if (window_activated_handler_)
+      window_activated_handler_->Invoke(this, NULL);
+  }
+
  private:
    PointerEventHandler* mouse_moved_handler_;
    PointerEventHandler* mouse_capture_lost_handler_;
    PointerEventHandler* mouse_pressed_handler_;
    PointerEventHandler* mouse_released_handler_;
    PointerEventHandler* mouse_entered_handler_;
    PointerEventHandler* mouse_exited_handler_;
    PointerEventHandler* mouse_wheel_changed_handler_;
    KeyEventHandler* key_down_handler_;
    KeyEventHandler* key_up_handler_;
    CharEventHandler* character_received_handler_;
    HWND core_hwnd_;
    mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher_;
+   mswr::ComPtr<winapp::Core::IFrameworkView> app_view_;
+   WindowActivatedHandler* window_activated_handler_;
 };
 
+LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
+                         WPARAM wparam, LPARAM lparam) {
+  PAINTSTRUCT ps;
+  HDC hdc;
+  switch (message) {
+    case WM_ACTIVATE: {
+      // HIWORD(wparam) is 1 if the window is minimized.
+      bool active = (LOWORD(wparam) != WA_INACTIVE) && !HIWORD(wparam);
+      if (active) {
+        CoreWindowEmulation* core_window_handler =
+            reinterpret_cast<CoreWindowEmulation*>(
+                ::GetProp(hwnd, kAshWin7CoreWindowHandler));
+        if (core_window_handler)
+          core_window_handler->OnWindowActivated();
+      }
+      return ::DefWindowProc(hwnd, message, wparam, lparam);
+    }
+    case WM_CREATE:
+      ++g_window_count;
+      break;
+    case WM_PAINT:
+      hdc = ::BeginPaint(hwnd, &ps);
+      ::EndPaint(hwnd, &ps);
+      break;
+    case WM_CLOSE:
+      ::DestroyWindow(hwnd);
+      break;
+    case WM_DESTROY:
+      --g_window_count;
+      if (!g_window_count)
+        ::PostQuitMessage(0);
+      break;
+    // Always allow Chrome to set the cursor.
+    case WM_SETCURSOR:
+      return 1;
+    default:
+      return ::DefWindowProc(hwnd, message, wparam, lparam);
+  }
+  return 0;
+}
+
 class ActivatedEvent
     : public mswr::RuntimeClass<winapp::Activation::IActivatedEventArgs> {
  public:
   ActivatedEvent(winapp::Activation::ActivationKind activation_kind)
     : activation_kind_(activation_kind) {
   }
 
   virtual HRESULT STDMETHODCALLTYPE get_Kind(
     winapp::Activation::ActivationKind *value) {
     *value = activation_kind_;
@@ skipping 11 matching lines @@
     return E_FAIL;
   }
 
  private:
   winapp::Activation::ActivationKind activation_kind_;
 };
 
 class CoreApplicationViewEmulation
     : public mswr::RuntimeClass<winapp::Core::ICoreApplicationView> {
  public:
-   CoreApplicationViewEmulation() {
-      core_window_ = mswr::Make<CoreWindowEmulation>();
+   CoreApplicationViewEmulation(winapp::Core::IFrameworkView* app_view) {
+      core_window_ = mswr::Make<CoreWindowEmulation>(app_view);
    }
 
   HRESULT Activate() {
     if (activated_handler_) {
       auto ae = mswr::Make<ActivatedEvent>(
         winapp::Activation::ActivationKind_File);
       return activated_handler_->Invoke(this, ae.Get());
     } else {
       return S_OK;
     }
@@ skipping 83 matching lines @@
   virtual HRESULT STDMETHODCALLTYPE GetCurrentView(
       winapp::Core::ICoreApplicationView** value) {
     return S_OK;
   }
 
   virtual HRESULT STDMETHODCALLTYPE Run(
       winapp::Core::IFrameworkViewSource* viewSource) {
     HRESULT hr = viewSource->CreateView(app_view_.GetAddressOf());
     if (FAILED(hr))
       return hr;
-    view_emulation_ = mswr::Make<CoreApplicationViewEmulation>();
+    view_emulation_ = mswr::Make<CoreApplicationViewEmulation>(
+        app_view_.Get());
     hr = app_view_->Initialize(view_emulation_.Get());
     if (FAILED(hr))
       return hr;
     mswr::ComPtr<winui::Core::ICoreWindow> core_window;
     hr = view_emulation_->get_CoreWindow(core_window.GetAddressOf());
     if (FAILED(hr))
       return hr;
     hr = app_view_->SetWindow(core_window.Get());
     if (FAILED(hr))
       return hr;
@@ skipping 34 matching lines @@
 };
 
 
 mswr::ComPtr<winapp::Core::ICoreApplication> InitWindows7() {
   HRESULT hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
   if (FAILED(hr))
     CHECK(false);
   return mswr::Make<CoreApplicationWin7Emulation>();
 }