Cleanup of the metro viewer code

win8/metro_driver/chrome_app_view_ash.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 "win8/metro_driver/stdafx.h"
 #include "win8/metro_driver/chrome_app_view_ash.h"
 
+#include <corewindow.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.h"
@@ skipping 29 matching lines @@
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
     winui::Core::VisibilityChangedEventArgs*> VisibilityChangedHandler;
 
 // This function is exported by chrome.exe.
 typedef int (__cdecl *BreakpadExceptionHandler)(EXCEPTION_POINTERS* info);
 
 // Global information used across the metro driver.
 struct Globals {
-  LPTHREAD_START_ROUTINE host_main;
-  HWND core_window;
-  DWORD main_thread_id;
   winapp::Activation::ApplicationExecutionState previous_state;
   winapp::Core::ICoreApplicationExit* app_exit;
   BreakpadExceptionHandler breakpad_exception_handler;
 } globals;
 
 namespace {
 
 // TODO(robertshield): Share this with chrome_app_view.cc
 void MetroExit() {
   globals.app_exit->Exit();
-  globals.core_window = NULL;
 }
 
 class ChromeChannelListener : public IPC::Listener {
  public:
   ChromeChannelListener(MessageLoop* ui_loop, ChromeAppViewAsh* app_view)
       : ui_proxy_(ui_loop->message_loop_proxy()),
         app_view_(app_view) {
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
@@ skipping 184 matching lines @@
   if (base::win::IsCtrlPressed())
     flags |= ui::EF_CONTROL_DOWN;
   if (base::win::IsAltPressed())
     flags |= ui::EF_ALT_DOWN;
   return flags;
 }
 
 }  // namespace
 
 ChromeAppViewAsh::ChromeAppViewAsh()
-    : mouse_down_flags_(ui::EF_NONE), ui_channel_(nullptr) {
+    : mouse_down_flags_(ui::EF_NONE),
+      ui_channel_(nullptr),
+      core_window_hwnd_(NULL) {
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
 }
 
 ChromeAppViewAsh::~ChromeAppViewAsh() {
   DVLOG(1) << __FUNCTION__;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Initialize(winapp::Core::ICoreApplicationView* view) {
   view_ = view;
   DVLOG(1) << __FUNCTION__;
-  globals.main_thread_id = ::GetCurrentThreadId();
-
   HRESULT hr = view_->add_Activated(mswr::Callback<ActivatedHandler>(
       this, &ChromeAppViewAsh::OnActivate).Get(),
       &activated_token_);
   CheckHR(hr);
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::SetWindow(winui::Core::ICoreWindow* window) {
   window_ = window;
   DVLOG(1) << __FUNCTION__;
+
+  // Retrieve the native window handle via the interop layer.
+  mswr::ComPtr<ICoreWindowInterop> interop;
+  HRESULT hr = window->QueryInterface(interop.GetAddressOf());
+  CheckHR(hr);
+  hr = interop->get_WindowHandle(&core_window_hwnd_);
+  CheckHR(hr);
+
   // Register for pointer and keyboard notifications. We forward
   // them to the browser process via IPC.
-  HRESULT hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
+  hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppViewAsh::OnPointerMoved).Get(),
       &pointermoved_token_);
   CheckHR(hr);
 
   hr = window_->add_PointerPressed(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppViewAsh::OnPointerPressed).Get(),
       &pointerpressed_token_);
   CheckHR(hr);
 
   hr = window_->add_PointerReleased(mswr::Callback<PointerEventHandler>(
@@ skipping 55 matching lines @@
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Run() {
   DVLOG(1) << __FUNCTION__;
   mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher;
   HRESULT hr = window_->get_Dispatcher(&dispatcher);
   CheckHR(hr, "Dispatcher failed.");
 
   hr = window_->Activate();
-  if (SUCCEEDED(hr)) {
-    // TODO(cpu): Draw something here.
-  } else {
-    DVLOG(1) << "Activate failed, hr=" << hr;
+  if (FAILED(hr)) {
+    DLOG(WARNING) << "activation failed hr=" << hr;
+    return hr;
   }
 
   // Create a message loop to allow message passing into this thread.
   MessageLoop msg_loop(MessageLoop::TYPE_UI);
 
   // Create the IPC channel IO thread. It needs to out-live the ChannelProxy.
   base::Thread io_thread("metro_IO_thread");
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   io_thread.StartWithOptions(options);
@@ skipping 10 matching lines @@
 
   // In Aura mode we create an IPC channel to the browser, then ask it to
   // connect to us.
   ChromeChannelListener ui_channel_listener(&msg_loop, this);
   IPC::ChannelProxy ui_channel(ipc_channel_name,
                                IPC::Channel::MODE_NAMED_CLIENT,
                                &ui_channel_listener,
                                io_thread.message_loop_proxy());
   ui_channel_ = &ui_channel;
 
+  // Upon receipt of the MetroViewerHostMsg_SetTargetSurface message the
+  // browser will use D3D from the browser process to present to our Window.
   ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
-                    gfx::NativeViewId(globals.core_window)));
-  DVLOG(1) << "ICoreWindow sent " << globals.core_window;
+                    gfx::NativeViewId(core_window_hwnd_)));
+  DVLOG(1) << "ICoreWindow sent " << core_window_hwnd_;
 
   // And post the task that'll do the inner Metro message pumping to it.
   msg_loop.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
   msg_loop.Run();
 
   DVLOG(0) << "ProcessEvents done, hr=" << hr;
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Uninitialize() {
   DVLOG(1) << __FUNCTION__;
   window_ = nullptr;
   view_ = nullptr;
+  core_window_hwnd_ = NULL;
   return S_OK;
 }
 
 // static
 HRESULT ChromeAppViewAsh::Unsnap() {
   mswr::ComPtr<winui::ViewManagement::IApplicationViewStatics> view_statics;
   HRESULT hr = winrt_utils::CreateActivationFactory(
       RuntimeClass_Windows_UI_ViewManagement_ApplicationView,
       view_statics.GetAddressOf());
   CheckHR(hr);
@@ skipping 79 matching lines @@
         save_file_picker->result(),
         save_file_picker->filter_index()));
   }
   delete save_file_picker;
 }
 
 HRESULT ChromeAppViewAsh::OnActivate(
     winapp::Core::ICoreApplicationView*,
     winapp::Activation::IActivatedEventArgs* args) {
   DVLOG(1) << __FUNCTION__;
-
+  // Note: If doing more work in this function, you migth need to call
+  // get_PreviousExecutionState() and skip the work if  the result is
+  // ApplicationExecutionState_Running and globals.previous_state is too.
   args->get_PreviousExecutionState(&globals.previous_state);
   DVLOG(1) << "Previous Execution State: " << globals.previous_state;
 
   window_->Activate();
-
-  if (globals.previous_state ==
-      winapp::Activation::ApplicationExecutionState_Running) {
-    DVLOG(1) << "Already running. Skipping rest of OnActivate.";
-    return S_OK;
-  }
-
-  globals.core_window =
-      winrt_utils::FindCoreWindow(globals.main_thread_id, 10);
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerMoved(winui::Core::ICoreWindow* sender,
                                          winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
@@ skipping 211 matching lines @@
   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   *view = mswr::Make<ChromeAppViewAsh>().Detach();
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }