// Copyright (c) 2013 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. #ifndef WIN8_VIEWER_METRO_VIEWER_PROCESS_HOST_H_ #define WIN8_VIEWER_METRO_VIEWER_PROCESS_HOST_H_ #include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "base/strings/string16.h" #include "base/threading/non_thread_safe.h" #include "ipc/ipc_channel_proxy.h" #include "ipc/ipc_listener.h" #include "ipc/ipc_sender.h" #include "ui/gfx/native_widget_types.h" namespace base { class SingleThreadTaskRunner; class WaitableEvent; } namespace IPC { class Message; } namespace win8 { // Abstract base class for various Metro viewer process host implementations. class MetroViewerProcessHost : public IPC::Listener, public IPC::Sender, public base::NonThreadSafe { public: // Initializes a viewer process host to connect to the Metro viewer process // over IPC. The given task runner correspond to a thread on which // IPC::Channel is created and used (e.g. IO thread). Instantly connects to // the viewer process if one is already connected to |ipc_channel_name|; a // viewer can otherwise be launched synchronously via // LaunchViewerAndWaitForConnection(). explicit MetroViewerProcessHost( base::SingleThreadTaskRunner* ipc_task_runner); virtual ~MetroViewerProcessHost(); // Returns the process id of the viewer process if one is connected to this // host, returns base::kNullProcessId otherwise. base::ProcessId GetViewerProcessId(); // Launches the viewer process associated with the given |app_user_model_id| // and blocks until that viewer process connects or until a timeout is // reached. Returns true if the viewer process connects before the timeout is // reached. NOTE: this assumes that the app referred to by |app_user_model_id| // is registered as the default browser. bool LaunchViewerAndWaitForConnection( const base::string16& app_user_model_id); private: // IPC::Sender implementation: virtual bool Send(IPC::Message* msg) OVERRIDE; // IPC::Listener implementation: virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; virtual void OnChannelError() OVERRIDE = 0; // Called over IPC by the viewer process to tell this host that it should be // drawing to |target_surface|. virtual void OnSetTargetSurface(gfx::NativeViewId target_surface) = 0; // Called over IPC by the viewer process to request that the url passed in be // opened. virtual void OnOpenURL(const base::string16& url) = 0; // Called over IPC by the viewer process to request that the search string // passed in is passed to the default search provider and a URL navigation be // performed. virtual void OnHandleSearchRequest(const base::string16& search_string) = 0; // Called over IPC by the viewer process when the window size has changed. virtual void OnWindowSizeChanged(uint32 width, uint32 height) = 0; void NotifyChannelConnected(); // Inner message filter used to handle connection event on the IPC channel // proxy's background thread. This prevents consumers of // MetroViewerProcessHost from having to pump messages on their own message // loop. class InternalMessageFilter : public IPC::ChannelProxy::MessageFilter { public: InternalMessageFilter(MetroViewerProcessHost* owner); // IPC::ChannelProxy::MessageFilter implementation. virtual void OnChannelConnected(int32 peer_pid) OVERRIDE; private: MetroViewerProcessHost* owner_; DISALLOW_COPY_AND_ASSIGN(InternalMessageFilter); }; scoped_ptr<IPC::ChannelProxy> channel_; scoped_ptr<base::WaitableEvent> channel_connected_event_; scoped_refptr<InternalMessageFilter> message_filter_; DISALLOW_COPY_AND_ASSIGN(MetroViewerProcessHost); }; } // namespace win8 #endif // WIN8_VIEWER_METRO_VIEWER_PROCESS_HOST_H_