root/win8/viewer/metro_viewer_process_host.h

INCLUDED FROM

// 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_