Add the ability for the GPU process to be used to paint the backing store of a

tab. This is the first pass and is currently a bit buggy and incomplete.

This patch refactors the backing store to make it a virtual interface which is
then implemented by the platform-specific backing stores. This cleans up the
multi-platform aspects of the old code, and also makes it possible to create
different backing stores (such as ones in another process).

This renames the BackingStore::PaintRect function to PaintToBackingStore which
clears up what it does. I would often get confused and think that it paints
the backing store to the screen.

This makes a common way to capture backing store information and adds it to the
backing store API. This removed a bunch of ugly ifdefs.

This adds the ability for a backing store to specify that the TransportDIB
should not be freed by RenderWidgetHost when painting is complete. This is
necessary since the out-of-process version needs to use it after the
RenderWidget paint function has returned.

This pushes up the vector of copy_rect from RenderWidgetHost to the actual
BackingStores. This prevents us from sending duplicate data over IPC. It also
makes the common non-IPC case more efficient, since we end up setting up various
surfaces only once when there are multiple update rects.

BUG=none
TEST=none
Review URL: http://codereview.chromium.org/523028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@36075 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 73 insertions, 0 deletions

diff --git a/chrome/browser/gpu_process_host.h b/chrome/browser/gpu_process_host.h
new file mode 100644
index 0000000..1856182
--- /dev/null
+++ b/chrome/browser/gpu_process_host.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2010 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 CHROME_BROWSER_GPU_PROCESS_HOST_H_
+#define CHROME_BROWSER_GPU_PROCESS_HOST_H_
+
+#include <queue>
+
+#include "app/gfx/native_widget_types.h"
+#include "base/basictypes.h"
+#include "base/scoped_ptr.h"
+#include "base/singleton.h"
+#include "chrome/browser/child_process_launcher.h"
+#include "chrome/common/message_router.h"
+#include "ipc/ipc_channel_proxy.h"
+
+class ChildProcessLauncher;
+
+class GpuProcessHost : public IPC::Channel::Sender,
+                       public IPC::Channel::Listener,
+                       public ChildProcessLauncher::Client {
+ public:
+  // Getter for the singleton. This will return NULL on failure.
+  static GpuProcessHost* Get();
+
+  int32 GetNextRoutingId();
+
+  // Creates the new remote view and returns the routing ID for the view, or 0
+  // on failure.
+  int32 NewRenderWidgetHostView(gfx::NativeViewId parent);
+
+  // IPC::Channel::Sender implementation.
+  virtual bool Send(IPC::Message* msg);
+
+  // IPC::Channel::Listener implementation.
+  virtual void OnMessageReceived(const IPC::Message& message);
+  virtual void OnChannelConnected(int32 peer_pid);
+  virtual void OnChannelError();
+
+  // ChildProcessLauncher::Client implementation.
+  virtual void OnProcessLaunched();
+
+  // See documentation on MessageRouter for AddRoute and RemoveRoute
+  void AddRoute(int32 routing_id, IPC::Channel::Listener* listener);
+  void RemoveRoute(int32 routing_id);
+
+ private:
+  friend struct DefaultSingletonTraits<GpuProcessHost>;
+
+  GpuProcessHost();
+  virtual ~GpuProcessHost();
+
+  scoped_ptr<ChildProcessLauncher> child_process_;
+
+  // A proxy for our IPC::Channel that lives on the IO thread (see
+  // browser_process.h). This will be NULL if the class failed to initialize.
+  scoped_ptr<IPC::ChannelProxy> channel_;
+
+  int last_routing_id_;
+
+  MessageRouter router_;
+
+  // Messages we queue while waiting for the process handle.  We queue them here
+  // instead of in the channel so that we ensure they're sent after init related
+  // messages that are sent once the process handle is available.  This is
+  // because the queued messages may have dependencies on the init messages.
+  std::queue<IPC::Message*> queued_messages_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
+};
+
+#endif  // CHROME_BROWSER_GPU_PROCESS_HOST_H_