chrome/browser/automation/automation_resource_tracker.h

   1 // Copyright (c) 2011 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_BROWSER_AUTOMATION_AUTOMATION_RESOURCE_TRACKER_H__
   6 #define CHROME_BROWSER_AUTOMATION_AUTOMATION_RESOURCE_TRACKER_H__
   7
   8 #include <map>
   9
  10 #include "base/basictypes.h"
  11 #include "content/public/browser/notification_observer.h"
  12 #include "content/public/browser/notification_registrar.h"
  13 #include "content/public/browser/notification_source.h"
  14 #include "content/public/browser/notification_types.h"
  15 #include "ipc/ipc_sender.h"
  16
  17 // Template trick so that AutomationResourceTracker can be used with non-pointer
  18 // types.
  19 template <class T>
  20 struct AutomationResourceTraits {
  21   typedef T ValueType;
  22 };
  23
  24 template <class T>
  25 struct AutomationResourceTraits<T*> {
  26   typedef T ValueType;
  27 };
  28
  29 // This class exists for the sole purpose of allowing some of the implementation
  30 // of AutomationResourceTracker to live in a .cc file.
  31 class AutomationResourceTrackerImpl {
  32  public:
  33   explicit AutomationResourceTrackerImpl(IPC::Sender* sender);
  34   virtual ~AutomationResourceTrackerImpl();
  35
  36  protected:
  37   // These need to be implemented in AutomationResourceTracker,
  38   // since it needs to call the subclass's type-specific notification
  39   // registration functions.
  40   virtual void AddObserverTypeProxy(const void* resource) = 0;
  41   virtual void RemoveObserverTypeProxy(const void* resource) = 0;
  42
  43   int AddImpl(const void* resource);
  44   void RemoveImpl(const void* resource);
  45   int GenerateHandle();
  46   bool ContainsResourceImpl(const void* resource);
  47   bool ContainsHandleImpl(int handle);
  48   const void* GetResourceImpl(int handle);
  49   int GetHandleImpl(const void* resource);
  50   void HandleCloseNotification(const void* resource);
  51
  52  private:
  53   typedef std::map<const void*, int> ResourceToHandleMap;
  54   typedef std::map<int, const void*> HandleToResourceMap;
  55
  56   ResourceToHandleMap resource_to_handle_;
  57   HandleToResourceMap handle_to_resource_;
  58
  59   IPC::Sender* sender_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(AutomationResourceTrackerImpl);
  62 };
  63
  64 // This template defines a superclass for an object that wants to track
  65 // a particular kind of application resource (like windows or tabs) for
  66 // automation purposes.  The only things that a subclass should need to
  67 // define are AddObserver and RemoveObserver for the given resource's
  68 // close notifications.
  69 template <class T>
  70 class AutomationResourceTracker : public AutomationResourceTrackerImpl,
  71                                   public content::NotificationObserver {
  72  public:
  73   explicit AutomationResourceTracker(IPC::Sender* automation)
  74       : AutomationResourceTrackerImpl(automation) {}
  75
  76   // The implementations for these should call the NotificationService
  77   // to add and remove this object as an observer for the appropriate
  78   // resource closing notification.
  79   virtual void AddObserver(T resource) = 0;
  80   virtual void RemoveObserver(T resource) = 0;
  81
  82   // Adds the given resource to this tracker, and returns a handle that
  83   // can be used to refer to that resource.  If the resource is already
  84   // being tracked, the handle may be the same as one returned previously.
  85   int Add(T resource) {
  86     return AddImpl(resource);
  87   }
  88
  89   // Removes the given resource from this tracker.  If the resource is not
  90   // currently present in the tracker, this is a no-op.
  91   void Remove(T resource) {
  92     RemoveImpl(resource);
  93   }
  94
  95   // Returns true if this tracker currently tracks the resource pointed to
  96   // by the parameter.
  97   bool ContainsResource(T resource) {
  98     return ContainsResourceImpl(resource);
  99   }
 100
 101   // Returns true if this tracker currently tracks the given handle.
 102   bool ContainsHandle(int handle) {
 103     return ContainsHandleImpl(handle);
 104   }
 105
 106   // Returns the resource pointer associated with a given handle, or NULL
 107   // if that handle is not present in the mapping.
 108   // The casts here allow this to compile with both T = Foo and T = const Foo.
 109   T GetResource(int handle) {
 110     return static_cast<T>(const_cast<void*>(GetResourceImpl(handle)));
 111   }
 112
 113   // Returns the handle associated with a given resource pointer, or 0 if
 114   // the resource is not currently in the mapping.
 115   int GetHandle(T resource) {
 116     return GetHandleImpl(resource);
 117   }
 118
 119   // content::NotificationObserver implementation--the only thing that this
 120   // tracker does in response to notifications is to tell the AutomationProxy
 121   // that the associated handle is now invalid.
 122   virtual void Observe(int type,
 123                        const content::NotificationSource& source,
 124                        const content::NotificationDetails& details) {
 125      T resource = content::Source<typename AutomationResourceTraits<T>::
 126          ValueType>(source).ptr();
 127
 128      CloseResource(resource);
 129   }
 130
 131  protected:
 132   // Removes |resource| from the tracker, and handles sending the close
 133   // notification back to the client. This typically should not be called
 134   // directly, unless there is no appropriate notification available
 135   // for the resource type.
 136   void CloseResource(T resource) {
 137     HandleCloseNotification(resource);
 138   }
 139
 140   // These proxy calls from the base Impl class to the template's subclss.
 141   // The casts here allow this to compile with both T = Foo and T = const Foo.
 142   virtual void AddObserverTypeProxy(const void* resource) {
 143     AddObserver(static_cast<T>(const_cast<void*>(resource)));
 144   }
 145   virtual void RemoveObserverTypeProxy(const void* resource) {
 146     RemoveObserver(static_cast<T>(const_cast<void*>(resource)));
 147   }
 148
 149   content::NotificationRegistrar registrar_;
 150
 151  private:
 152   DISALLOW_COPY_AND_ASSIGN(AutomationResourceTracker);
 153 };
 154
 155 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_RESOURCE_TRACKER_H__