Split the IPC code into ipc/

This splits the ipc code from the common project.  The 'common' project pulls in
all of webkit, the v8 bindings, skia, googleurl, and a number of other projects
which makes it very difficult to deal with especially for external projects
wanting just to use some of Chromium's infrastructure.  This puts the ipc code
into its top-level ipc/ directory with a dependency only on base.  The common
project depends on the new ipc/ipc.gyp:ipc target so that all projects currently
pulling common in to get the IPC code still have it available.  This mostly
follows agl's pre-gyp attempt to do this which was r13062.

Known issues:
- Currently a number of projects depend on chrome/chrome.gyp:common in order to
use the IPC infrastructure.  Rather than fixing all of these dependencies I have
made common depend on ipc/ipc.gyp:ipc and added "ipc" to the include_rules
section of DEPS so that checkdeps.py doesn't complain.  Over time projects that
need IPC should depend on the IPC project themselves and dependencies on common
removed, although I don't think many projects that need IPC will be able to get
away without common currently.
- ipc/ipc_message_macros.h still has #include "chrome/common/..." inside of a
ipc/ should not refer to files in chrome/... now.  I'm not sure how to resolve
this since it's really an IDE bug
- the named pipe name (windows+linux) and the logging event name (all) + env
variable (posix) refer explicitly to 'Chrome' which somewhat hurts the illusion
of ipc/ being an independent library.  I think this should be examined in a
subsequent, much smaller patch.
- I've eliminated the IPC.SendMsgCount counter since it was implemented in a way
to create a dependency from ipc/ to chrome/common/chrome_counters. This is the
same approach that r13062 took.

http://codereview.chromium.org/155905

(Patch from James Robinson)


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

1 files changed, 112 insertions, 0 deletions

diff --git a/ipc/ipc_logging.h b/ipc/ipc_logging.h
new file mode 100644
index 0000000..364ad79
--- /dev/null
+++ b/ipc/ipc_logging.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2006-2008 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 IPC_IPC_LOGGING_H_
+#define IPC_IPC_LOGGING_H_
+
+#include "ipc/ipc_message.h"  // For IPC_MESSAGE_LOG_ENABLED.
+
+#ifdef IPC_MESSAGE_LOG_ENABLED
+
+#include <vector>
+
+#include "base/message_loop.h"
+#include "base/scoped_ptr.h"
+#include "base/singleton.h"
+#include "base/waitable_event_watcher.h"
+
+namespace IPC {
+
+class Message;
+
+// One instance per process.  Needs to be created on the main thread (the UI
+// thread in the browser) but OnPreDispatchMessage/OnPostDispatchMessage
+// can be called on other threads.
+class Logging : public base::WaitableEventWatcher::Delegate,
+                public MessageLoop::DestructionObserver {
+ public:
+  // Implemented by consumers of log messages.
+  class Consumer {
+   public:
+    virtual void Log(const LogData& data) = 0;
+  };
+
+  void SetConsumer(Consumer* consumer);
+
+  ~Logging();
+  static Logging* current();
+
+  void Enable();
+  void Disable();
+  bool Enabled() const { return enabled_; }
+
+  // Called by child processes to give the logger object the channel to send
+  // logging data to the browser process.
+  void SetIPCSender(Message::Sender* sender);
+
+  // Called in the browser process when logging data from a child process is
+  // received.
+  void OnReceivedLoggingMessage(const Message& message);
+
+  void OnSendMessage(Message* message, const std::string& channel_id);
+  void OnPreDispatchMessage(const Message& message);
+  void OnPostDispatchMessage(const Message& message,
+                             const std::string& channel_id);
+
+  // Returns the name of the logging enabled/disabled events so that the
+  // sandbox can add them to to the policy.  If true, gets the name of the
+  // enabled event, if false, gets the name of the disabled event.
+  static std::wstring GetEventName(bool enabled);
+
+  // Like the *MsgLog functions declared for each message class, except this
+  // calls the correct one based on the message type automatically.  Defined in
+  // ipc_logging.cc.
+  static void GetMessageText(uint16 type, std::wstring* name,
+                             const Message* message, std::wstring* params);
+
+  // WaitableEventWatcher::Delegate implementation
+  void OnWaitableEventSignaled(base::WaitableEvent* event);
+
+  // MessageLoop::DestructionObserver implementation
+  void WillDestroyCurrentMessageLoop();
+
+  typedef void (*LogFunction)(uint16 type,
+                             std::wstring* name,
+                             const Message* msg,
+                             std::wstring* params);
+
+  static void SetLoggerFunctions(LogFunction *functions);
+
+ private:
+  friend struct DefaultSingletonTraits<Logging>;
+  Logging();
+
+  std::wstring GetEventName(int browser_pid, bool enabled);
+  void OnSendLogs();
+  void Log(const LogData& data);
+
+  void RegisterWaitForEvent(bool enabled);
+
+  base::WaitableEventWatcher watcher_;
+
+  scoped_ptr<base::WaitableEvent> logging_event_on_;
+  scoped_ptr<base::WaitableEvent> logging_event_off_;
+  bool enabled_;
+
+  std::vector<LogData> queued_logs_;
+  bool queue_invoke_later_pending_;
+
+  Message::Sender* sender_;
+  MessageLoop* main_thread_;
+
+  Consumer* consumer_;
+
+  static LogFunction *log_function_mapping_;
+};
+
+}  // namespace IPC
+
+#endif // IPC_MESSAGE_LOG_ENABLED
+
+#endif  // IPC_IPC_LOGGING_H_