in-chrome viewer for metro

win8/metro_driver/chrome_app_view.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.h"
+#include "win8/metro_driver/direct3d_helper.h"
 
 #include <algorithm>
 #include <windows.applicationModel.datatransfer.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/win/metro.h"
 
+#include "base/threading/thread.h"
+#include "ipc/ipc_channel.h"
+#include "ipc/ipc_channel_proxy.h"
+#include "ipc/ipc_sender.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/metro_viewer/metro_viewer_messages.h"
+
 // This include allows to send WM_SYSCOMMANDs to chrome.
 #include "chrome/app/chrome_command_ids.h"
 #include "win8/metro_driver/winrt_utils.h"
 #include "ui/base/ui_base_switches.h"
 
+
 typedef winfoundtn::ITypedEventHandler<
     winapp::Core::CoreApplicationView*,
     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
     winui::Core::WindowSizeChangedEventArgs*> SizeChangedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Input::EdgeGesture*,
@@ skipping 232 matching lines @@
 
     DVLOG(1) << "Hiding current top window:"
             << reinterpret_cast<int>(current_top_window.first);
     AnimateWindow(current_top_window.first, kAnimateWindowTimeoutMs,
                   AW_HIDE | AW_HOR_POSITIVE | AW_SLIDE);
 
     globals.host_windows.push_back(current_top_window);
   }
 }
 
+class ChromeChannelListener : public IPC::Listener {
+ public:
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    DVLOG(1) << "Received ipc message " << message.type();
+    return true;
+  }
+
+  virtual void OnChannelError() OVERRIDE {
+    DVLOG(1) << "Channel error";
+    MessageLoop::current()->Quit();
+  }
+
+  void Init(IPC::Sender* s) {
+    sender_ = s;
+  }
+
+ private:
+  IPC::Sender* sender_;
+};
+
 }  // namespace
 
 HRESULT ChromeAppView::TileRequestCreateDone(
     winfoundtn::IAsyncOperation<bool>* async,
     AsyncStatus status) {
   if (status == Completed) {
     unsigned char result;
     CheckHR(async->GetResults(&result));
     DVLOG(1) << __FUNCTION__ << " result " << static_cast<int>(result);
   } else {
@@ skipping 413 matching lines @@
   // chrome. Uncomment this once we figure out why they don't fire.
   // RegisterInputPaneNotifications();
 
   hr = winrt_utils::CreateActivationFactory(
       RuntimeClass_Windows_UI_ViewManagement_ApplicationView,
       app_view_.GetAddressOf());
   CheckHR(hr);
 
   DVLOG(1) << "Created appview instance.";
 
+  direct3d_helper_.Initialize(window);
+
+  DVLOG(1) << "Initialized Direct3D.";
+
   hr = devices_handler_.Initialize(window);
   // Don't check or return the failure here, we need to let the app
   // initialization succeed. Even if we won't be able to access devices
   // we still want to allow the app to start.
   LOG_IF(ERROR, FAILED(hr)) << "Failed to initialize devices handler.";
   return S_OK;
 }
 
 IFACEMETHODIMP
 ChromeAppView::Load(HSTRING entryPoint) {
@@ skipping 51 matching lines @@
   }
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ChromeAppView::CheckForOSKActivation,
                  base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(kCheckOSKDelayMs));
 }
 
 IFACEMETHODIMP
 ChromeAppView::Run() {
-  DVLOG(1) << __FUNCTION__ << ", hwnd=" << LONG_PTR(window_.Get());
+  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;
   }
 
   // Create a message loop to allow message passing into this thread.
   MessageLoop msg_loop(MessageLoop::TYPE_UI);
 
   // Announce our message loop to the world.
   globals.appview_msg_loop = msg_loop.message_loop_proxy();
 
+  // The thread needs to out-live the ChannelProxy.
+  base::Thread thread("metro_IO_thread");
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  thread.StartWithOptions(options);
+
+  ChromeChannelListener channel_listener;
+  IPC::ChannelProxy chan("viewer", IPC::Channel::MODE_NAMED_CLIENT,
+                         &channel_listener, thread.message_loop_proxy());
+  channel_listener.Init(&chan);
+  chan.Send(new MetroViewerHostMsg_SetTargetSurface(
+        gfx::NativeViewId(globals.core_window)));
+
+  DVLOG(1) << "ICoreWindow sent " << globals.core_window;
+
   // And post the task that'll do the inner Metro message pumping to it.
   msg_loop.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
 
   // Post the recurring task which checks for OSK activation in metro chrome.
   // Please refer to the comments in the CheckForOSKActivation function for why
   // this is needed.
   // TODO(ananta)
   // Take this out when the documented OSK notifications start working.
   msg_loop.PostDelayedTask(
       FROM_HERE,
@@ skipping 88 matching lines @@
     return S_OK;
   }
 
   do {
     ::Sleep(10);
     ::EnumThreadWindows(globals.main_thread_id, &CoreWindowFinder, 0);
   } while (globals.core_window == NULL);
 
   DVLOG(1) << "CoreWindow found: " << std::hex << globals.core_window;
 
+
+#if !defined(USE_AURA)
   if (!globals.host_thread) {
     DWORD chrome_ui_thread_id = 0;
     globals.host_thread =
         ::CreateThread(NULL, 0, HostMainThreadProc, NULL, 0,
-                       &chrome_ui_thread_id);
+                      &chrome_ui_thread_id);
 
     if (!globals.host_thread) {
       NOTREACHED() << "thread creation failed.";
       return E_UNEXPECTED;
     }
   }
+#endif
 
   if (RegisterHotKey(globals.core_window, kFlipWindowsHotKeyId,
                      MOD_CONTROL, VK_F12)) {
     DVLOG(1) << "Registered flip window hotkey.";
   } else {
     VPLOG(1) << "Failed to register flip window hotkey.";
   }
   HRESULT hr = settings_handler_.Initialize();
   CheckHR(hr,"Failed to initialize settings handler.");
   return hr;
@@ skipping 258 matching lines @@
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   globals.view = mswr::Make<ChromeAppView>().Detach();
   *view = globals.view;
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }