Introduce RenderFrameObserver.

content/public/renderer/render_frame_observer_tracker.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 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.
 
-// Helper class used to find the RenderViewObservers for a given RenderView.
+// Helper class used to find the RenderFrameObservers for a given RenderFrame.
 //
 // Example usage:
 //
-//   class MyRVO : public RenderViewObserver,
-//                 public RenderViewObserverTracker<MyRVO> {
+//   class MyRFO : public RenderFrameObserver,
+//                 public RenderFrameObserverTracker<MyRFO> {
 //     ...
 //   };
 //
-//   MyRVO::MyRVO(RenderView* render_view)
-//       : RenderViewObserver(render_view),
-//         RenderViewObserverTracker<MyRVO>(render_view) {
+//   MyRFO::MyRFO(RenderFrame* render_frame)
+//       : RenderFrameObserver(render_frame),
+//         RenderFrameObserverTracker<MyRFO>(render_frame) {
 //     ...
 //   }
 //
-//  void SomeFunction(RenderView* rv) {
-//    MyRVO* my_rvo = new MyRVO(rv);
-//    MyRVO* my_rvo_tracked = MyRVO::Get(rv);
-//    // my_rvo == my_rvo_tracked
+//  void SomeFunction(RenderFrame* rf) {
+//    MyRFO* my_rfo = new MyRFO(rf);
+//    MyRFO* my_rfo_tracked = MyRFO::Get(rf);
+//    // my_rfo == my_rfo_tracked
 //  }
 
-#ifndef CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_TRACKER_H_
-#define CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_TRACKER_H_
+#ifndef CONTENT_PUBLIC_RENDERER_RENDER_FRAME_OBSERVER_TRACKER_H_
+#define CONTENT_PUBLIC_RENDERER_RENDER_FRAME_OBSERVER_TRACKER_H_
 
 #include <map>
 
 #include "base/lazy_instance.h"
 
 namespace content {
 
-class RenderView;
+class RenderFrame;
 
 template <class T>
-class RenderViewObserverTracker {
+class RenderFrameObserverTracker {
  public:
-  static T* Get(const RenderView* render_view) {
-    return render_view_map_.Get()[render_view];
+  static T* Get(const RenderFrame* render_frame) {
+    return render_frame_map_.Get()[render_frame];
   }
 
-  explicit RenderViewObserverTracker(const RenderView* render_view)
-      : render_view_(render_view) {
-    render_view_map_.Get()[render_view] = static_cast<T*>(this);
+  explicit RenderFrameObserverTracker(const RenderFrame* render_frame)
+      : render_frame_(render_frame) {
+    render_frame_map_.Get()[render_frame] = static_cast<T*>(this);
   }
-  ~RenderViewObserverTracker() {
-    render_view_map_.Get().erase(render_view_);
+  ~RenderFrameObserverTracker() {
+    render_frame_map_.Get().erase(render_frame_);
   }
 
  private:
-  const RenderView* render_view_;
+  const RenderFrame* render_frame_;
 
-  static base::LazyInstance<std::map<const RenderView*, T*> >
-    render_view_map_;
+  static base::LazyInstance<std::map<const RenderFrame*, T*> >
+    render_frame_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(RenderViewObserverTracker<T>);
+  DISALLOW_COPY_AND_ASSIGN(RenderFrameObserverTracker<T>);
 };
 
 template <class T>
-base::LazyInstance<std::map<const RenderView*, T*> >
-    RenderViewObserverTracker<T>::render_view_map_ = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<std::map<const RenderFrame*, T*> >
+    RenderFrameObserverTracker<T>::render_frame_map_ =
+        LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace content
 
-#endif  // CONTENT_PUBLIC_RENDERER_RENDER_VIEW_OBSERVER_TRACKER_H_
+#endif  // CONTENT_PUBLIC_RENDERER_RENDER_FRAME_OBSERVER_TRACKER_H_