Renames html_viewer frame classes

components/html_viewer/html_frame.h

Index: components/html_viewer/html_frame.h
diff --git a/components/html_viewer/frame.h b/components/html_viewer/html_frame.h
similarity index 83%
rename from components/html_viewer/frame.h
rename to components/html_viewer/html_frame.h
index c49b63a8daaa5f44b64a7e3e5c05b65f816a72f4..f398e582d717d6b3f5e65ad06bf08b4e5b6548e9 100644
--- a/components/html_viewer/frame.h
+++ b/components/html_viewer/html_frame.h
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_HTML_VIEWER_FRAME_H_
-#define COMPONENTS_HTML_VIEWER_FRAME_H_
+#ifndef COMPONENTS_HTML_VIEWER_HTML_FRAME_H_
+#define COMPONENTS_HTML_VIEWER_HTML_FRAME_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "components/html_viewer/frame_tree_manager.h"
+#include "components/html_viewer/html_frame_tree_manager.h"
 #include "components/view_manager/public/cpp/view_observer.h"
 #include "mandoline/tab/public/interfaces/frame_tree.mojom.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
@@ -29,32 +29,33 @@ class View;
 
 namespace html_viewer {
 
-class FrameTreeManager;
 class GeolocationClientImpl;
+class HTMLFrameTreeManager;
 class TouchHandler;
 class WebLayerImpl;
 class WebLayerTreeViewImpl;
 
 // Frame is used to represent a single frame in the frame tree of a page. The
 // frame is either local or remote. Each Frame is associated with a single
-// FrameTreeManager and can not be moved to another FrameTreeManager. Local
+// HTMLFrameTreeManager and can not be moved to another HTMLFrameTreeManager.
+// Local
 // frames have a mojo::View, remote frames do not.
-class Frame : public blink::WebFrameClient,
-              public blink::WebViewClient,
-              public blink::WebRemoteFrameClient,
-              public mojo::ViewObserver {
+class HTMLFrame : public blink::WebFrameClient,
+                  public blink::WebViewClient,
+                  public blink::WebRemoteFrameClient,
+                  public mojo::ViewObserver {
  public:
   struct CreateParams {
-    CreateParams(FrameTreeManager* manager, Frame* parent, uint32_t id)
+    CreateParams(HTMLFrameTreeManager* manager, HTMLFrame* parent, uint32_t id)
         : manager(manager), parent(parent), id(id) {}
     ~CreateParams() {}
 
-    FrameTreeManager* manager;
-    Frame* parent;
+    HTMLFrameTreeManager* manager;
+    HTMLFrame* parent;
     uint32_t id;
   };
 
-  explicit Frame(const CreateParams& params);
+  explicit HTMLFrame(const CreateParams& params);
 
   void Init(mojo::View* local_view,
             const blink::WebString& remote_frame_name,
@@ -66,14 +67,15 @@ class Frame : public blink::WebFrameClient,
   uint32_t id() const { return id_; }
 
   // Returns the Frame whose id is |id|.
-  Frame* FindFrame(uint32_t id) {
-    return const_cast<Frame*>(const_cast<const Frame*>(this)->FindFrame(id));
+  HTMLFrame* FindFrame(uint32_t id) {
+    return const_cast<HTMLFrame*>(
+        const_cast<const HTMLFrame*>(this)->FindFrame(id));
   }
-  const Frame* FindFrame(uint32_t id) const;
+  const HTMLFrame* FindFrame(uint32_t id) const;
 
-  Frame* parent() { return parent_; }
+  HTMLFrame* parent() { return parent_; }
 
-  const std::vector<Frame*>& children() { return children_; }
+  const std::vector<HTMLFrame*>& children() { return children_; }
 
   // Returns the WebFrame for this Frame. This is either a WebLocalFrame or
   // WebRemoteFrame.
@@ -89,9 +91,9 @@ class Frame : public blink::WebFrameClient,
   mojo::View* view() { return view_; }
 
  private:
-  friend class FrameTreeManager;
+  friend class HTMLFrameTreeManager;
 
-  virtual ~Frame();
+  virtual ~HTMLFrame();
 
   // Sets the name of the remote frame. Does nothing if this is a local frame.
   void SetRemoteFrameName(const mojo::String& name);
@@ -120,7 +122,7 @@ class Frame : public blink::WebFrameClient,
   GlobalState* global_state() { return frame_tree_manager_->global_state(); }
 
   // Returns the Frame associated with the specified WebFrame.
-  Frame* FindFrameWithWebFrame(blink::WebFrame* web_frame);
+  HTMLFrame* FindFrameWithWebFrame(blink::WebFrame* web_frame);
 
   // The various frameDetached() implementations call into this.
   void FrameDetachedImpl(blink::WebFrame* web_frame);
@@ -185,13 +187,13 @@ class Frame : public blink::WebFrameClient,
   virtual void reload(bool ignore_cache, bool is_client_redirect);
   virtual void forwardInputEvent(const blink::WebInputEvent* event);
 
-  FrameTreeManager* frame_tree_manager_;
-  Frame* parent_;
+  HTMLFrameTreeManager* frame_tree_manager_;
+  HTMLFrame* parent_;
   mojo::View* view_;
   // The id for this frame. If there is a view, this is the same id as the
   // view has.
   const uint32_t id_;
-  std::vector<Frame*> children_;
+  std::vector<HTMLFrame*> children_;
   blink::WebFrame* web_frame_;
   blink::WebWidget* web_widget_;
   scoped_ptr<GeolocationClientImpl> geolocation_client_impl_;
@@ -203,11 +205,11 @@ class Frame : public blink::WebFrameClient,
 
   scoped_ptr<WebLayerImpl> web_layer_;
 
-  base::WeakPtrFactory<Frame> weak_factory_;
+  base::WeakPtrFactory<HTMLFrame> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(Frame);
+  DISALLOW_COPY_AND_ASSIGN(HTMLFrame);
 };
 
 }  // namespace html_viewer
 
-#endif  // COMPONENTS_HTML_VIEWER_FRAME_H_
+#endif  // COMPONENTS_HTML_VIEWER_HTML_FRAME_H_