LCOV - app.info - ipc/chromium/src/chrome/common/child_process_host.h

LCOV - code coverage report
| Current view: | directory - ipc/chromium/src/chrome/common - child_process_host.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 6 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 7 | 0 | 0.0 %

           1                 : // Copyright (c) 2009 The Chromium Authors. All rights reserved.
           2                 : // Use of this source code is governed by a BSD-style license that can be
           3                 : // found in the LICENSE file.
           4                 :
           5                 : #ifndef CHROME_COMMON_CHILD_PROCESS_HOST_H_
           6                 : #define CHROME_COMMON_CHILD_PROCESS_HOST_H_
           7                 :
           8                 : #include "build/build_config.h"
           9                 :
          10                 : #include <list>
          11                 :
          12                 : #include "base/basictypes.h"
          13                 : #include "base/scoped_ptr.h"
          14                 : #include "base/waitable_event_watcher.h"
          15                 : class ResourceDispatcherHost;
          16                 : #include "chrome/common/child_process_info.h"
          17                 : #include "chrome/common/ipc_channel.h"
          18                 :
          19                 : class NotificationType;
          20                 :
          21                 : // Plugins/workers and other child processes that live on the IO thread should
          22                 : // derive from this class.
          23                 : class ChildProcessHost :
          24                 :                          public IPC::Message::Sender,
          25                 :                          public ChildProcessInfo,
          26                 :                          public base::WaitableEventWatcher::Delegate,
          27                 :                          public IPC::Channel::Listener {
          28                 :  public:
          29                 :   virtual ~ChildProcessHost();
          30                 :
          31                 :   // ResourceDispatcherHost::Receiver implementation:
          32                 :   virtual bool Send(IPC::Message* msg);
          33                 :
          34                 :   // The Iterator class allows iteration through either all child processes, or
          35                 :   // ones of a specific type, depending on which constructor is used.  Note that
          36                 :   // this should be done from the IO thread and that the iterator should not be
          37                 :   // kept around as it may be invalidated on subsequent event processing in the
          38                 :   // event loop.
          39                 :   class Iterator {
          40                 :    public:
          41                 :     Iterator();
          42                 :     Iterator(ProcessType type);
          43                 :     ChildProcessHost* operator->() { return *iterator_; }
          44                 :     ChildProcessHost* operator*() { return *iterator_; }
          45                 :     ChildProcessHost* operator++();
          46                 :     bool Done();
          47                 :
          48                 :    private:
          49                 :     bool all_;
          50                 :     ProcessType type_;
          51                 :     std::list<ChildProcessHost*>::iterator iterator_;
          52                 :   };
          53                 :
          54                 :  protected:
          55                 :   ChildProcessHost(ProcessType type,
          56                 :                    ResourceDispatcherHost* resource_dispatcher_host = 0);
          57                 :
          58                 :   // Derived classes return true if it's ok to shut down the child process.
          59                 :   virtual bool CanShutdown() = 0;
          60                 :
          61                 :   // Creates the IPC channel.  Returns true iff it succeeded.
          62                 :   bool CreateChannel();
          63                 :
          64                 :   // Once the subclass gets a handle to the process, it needs to tell
          65                 :   // ChildProcessHost using this function.
          66                 :   void SetHandle(base::ProcessHandle handle);
          67                 :
          68                 :   // Notifies us that an instance has been created on this child process.
          69                 :   void InstanceCreated();
          70                 :
          71                 :   // IPC::Channel::Listener implementation:
          72               0 :   virtual void OnMessageReceived(const IPC::Message& msg) { }
          73               0 :   virtual void OnChannelConnected(int32 peer_pid) { }
          74               0 :   virtual void OnChannelError() { }
          75                 :
          76                 :   bool opening_channel() { return opening_channel_; }
          77                 :   const std::wstring& channel_id() { return channel_id_; }
          78                 :
          79                 :   base::WaitableEvent* GetProcessEvent() { return process_event_.get(); }
          80                 :
          81               0 :   const IPC::Channel& channel() const { return *channel_; }
          82               0 :   IPC::Channel* channelp() const { return channel_.get(); }
          83                 :
          84                 :  private:
          85                 :   // Sends the given notification to the notification service on the UI thread.
          86                 :   void Notify(NotificationType type);
          87                 :
          88                 :  protected:
          89                 :   // WaitableEventWatcher::Delegate implementation:
          90                 :   virtual void OnWaitableEventSignaled(base::WaitableEvent *event);
          91                 :
          92                 :  private:
          93                 :   // By using an internal class as the IPC::Channel::Listener, we can intercept
          94                 :   // OnMessageReceived/OnChannelConnected and do our own processing before
          95                 :   // calling the subclass' implementation.
          96               0 :   class ListenerHook : public IPC::Channel::Listener {
          97                 :    public:
          98                 :     ListenerHook(ChildProcessHost* host);
          99                 :     virtual void OnMessageReceived(const IPC::Message& msg);
         100                 :     virtual void OnChannelConnected(int32 peer_pid);
         101                 :     virtual void OnChannelError();
         102                 :    private:
         103                 :     ChildProcessHost* host_;
         104                 :   };
         105                 :
         106                 :   ListenerHook listener_;
         107                 :
         108                 :   ResourceDispatcherHost* resource_dispatcher_host_;
         109                 :
         110                 :   // True while we're waiting the channel to be opened.
         111                 :   bool opening_channel_;
         112                 :
         113                 :   // The IPC::Channel.
         114                 :   scoped_ptr<IPC::Channel> channel_;
         115                 :
         116                 :   // IPC Channel's id.
         117                 :   std::wstring channel_id_;
         118                 :
         119                 :   // Used to watch the child process handle.
         120                 :   base::WaitableEventWatcher watcher_;
         121                 :
         122                 :   scoped_ptr<base::WaitableEvent> process_event_;
         123                 : };
         124                 :
         125                 : #endif  // CHROME_COMMON_CHILD_PROCESS_HOST_H_

Generated by: LCOV version 1.7