Rename frame classes

components/html_viewer/html_frame.cc

 // Copyright 2015 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.
 
 #include "components/html_viewer/html_frame.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 #include "url/url_constants.h"
 
 using mojo::AxProvider;
 using mojo::Rect;
 using mojo::ServiceProviderPtr;
 using mojo::URLResponsePtr;
 using mus::View;
-using web_view::HTMLMessageEvent;
-using web_view::HTMLMessageEventPtr;
+using web_view::mojom::HTMLMessageEvent;
+using web_view::mojom::HTMLMessageEventPtr;
 
 namespace html_viewer {
 namespace {
 
 const size_t kMaxTitleChars = 4 * 1024;
 
-web_view::NavigationTargetType WebNavigationPolicyToNavigationTarget(
+web_view::mojom::NavigationTargetType WebNavigationPolicyToNavigationTarget(
     blink::WebNavigationPolicy policy) {
   switch (policy) {
     case blink::WebNavigationPolicyCurrentTab:
-      return web_view::NAVIGATION_TARGET_TYPE_EXISTING_FRAME;
+      return web_view::mojom::NAVIGATION_TARGET_TYPE_EXISTING_FRAME;
     case blink::WebNavigationPolicyNewBackgroundTab:
     case blink::WebNavigationPolicyNewForegroundTab:
     case blink::WebNavigationPolicyNewWindow:
     case blink::WebNavigationPolicyNewPopup:
-      return web_view::NAVIGATION_TARGET_TYPE_NEW_FRAME;
+      return web_view::mojom::NAVIGATION_TARGET_TYPE_NEW_FRAME;
     default:
-      return web_view::NAVIGATION_TARGET_TYPE_NO_PREFERENCE;
+      return web_view::mojom::NAVIGATION_TARGET_TYPE_NO_PREFERENCE;
   }
 }
 
 HTMLFrame* GetPreviousSibling(HTMLFrame* frame) {
   DCHECK(frame->parent());
   auto iter = std::find(frame->parent()->children().begin(),
                         frame->parent()->children().end(), frame);
   return (iter == frame->parent()->children().begin()) ? nullptr : *(--iter);
 }
 
@@ skipping 202 matching lines @@
   view_->AddChild(child_view);
 
   HTMLFrame::CreateParams params(frame_tree_manager_, this, child_view->id(),
                                  child_view, client_properties, nullptr);
   params.is_local_create_child = true;
   HTMLFrame* child_frame = GetFirstAncestorWithDelegate()
                                ->delegate_->GetHTMLFactory()
                                ->CreateHTMLFrame(&params);
   child_frame->owned_view_.reset(new mus::ScopedViewPtr(child_view));
 
-  web_view::FrameTreeClientPtr client_ptr;
-  child_frame->frame_tree_client_binding_.reset(
-      new mojo::Binding<web_view::FrameTreeClient>(
+  web_view::mojom::FrameClientPtr client_ptr;
+  child_frame->frame_client_binding_.reset(
+      new mojo::Binding<web_view::mojom::FrameClient>(
           child_frame, mojo::GetProxy(&client_ptr)));
   server_->OnCreatedFrame(GetProxy(&(child_frame->server_)), client_ptr.Pass(),
                           child_view->id(), client_properties.Pass());
   return child_frame->web_frame_;
 }
 
 void HTMLFrame::frameDetached(blink::WebFrame* web_frame,
                               blink::WebFrameClient::DetachType type) {
   if (type == blink::WebFrameClient::DetachType::Swap) {
     web_frame->close();
@@ skipping 20 matching lines @@
     return blink::WebNavigationPolicyCurrentTab;
   }
 
   // about:blank is treated as the same origin and is always allowed for
   // frames.
   if (parent_ && info.urlRequest.url() == GURL(url::kAboutBlankURL) &&
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab) {
     return blink::WebNavigationPolicyCurrentTab;
   }
 
-  // Ask the FrameTreeServer to handle the navigation. By returning
+  // Ask the Frame to handle the navigation. By returning
   // WebNavigationPolicyIgnore the load is suppressed.
   mojo::URLRequestPtr url_request = mojo::URLRequest::From(info.urlRequest);
   server_->RequestNavigate(
       WebNavigationPolicyToNavigationTarget(info.defaultPolicy), id_,
       url_request.Pass());
 
   return blink::WebNavigationPolicyIgnore;
 }
 
 void HTMLFrame::didHandleOnloadEvents(blink::WebLocalFrame* frame) {
@@ skipping 82 matching lines @@
                                 blink::WebTextDirection direction) {
   // TODO(beng): handle |direction|.
   mojo::String formatted;
   if (!title.isNull()) {
     formatted =
         mojo::String::From(base::string16(title).substr(0, kMaxTitleChars));
   }
   server_->TitleChanged(formatted);
 }
 
-void HTMLFrame::Bind(web_view::FrameTreeServerPtr frame_tree_server,
-                     mojo::InterfaceRequest<web_view::FrameTreeClient>
-                         frame_tree_client_request) {
+void HTMLFrame::Bind(
+    web_view::mojom::FramePtr frame,
+    mojo::InterfaceRequest<web_view::mojom::FrameClient> frame_client_request) {
   DCHECK(IsLocal());
-  server_ = frame_tree_server.Pass();
+  server_ = frame.Pass();
   server_.set_connection_error_handler(
       base::Bind(&HTMLFrame::Close, base::Unretained(this)));
-  frame_tree_client_binding_.reset(new mojo::Binding<web_view::FrameTreeClient>(
-      this, frame_tree_client_request.Pass()));
+  frame_client_binding_.reset(new mojo::Binding<web_view::mojom::FrameClient>(
+      this, frame_client_request.Pass()));
 }
 
 void HTMLFrame::SetValueFromClientProperty(const std::string& name,
                                            mojo::Array<uint8_t> new_data) {
   if (IsLocal())
     return;
 
   // Only the name and origin dynamically change.
   if (name == kPropertyFrameOrigin) {
     state_.origin = FrameOriginFromClientProperty(new_data);
     web_frame_->toWebRemoteFrame()->setReplicatedOrigin(state_.origin);
   } else if (name == kPropertyFrameName) {
     state_.name = FrameNameFromClientProperty(new_data);
     web_frame_->toWebRemoteFrame()->setReplicatedName(state_.name);
   }
 }
 
 HTMLFrame* HTMLFrame::GetFirstAncestorWithDelegate() {
   HTMLFrame* frame = this;
   while (frame && !frame->delegate_)
     frame = frame->parent_;
   return frame;
 }
 
 mojo::ApplicationImpl* HTMLFrame::GetApp() {
   return GetFirstAncestorWithDelegate()->delegate_->GetApp();
 }
 
-web_view::FrameTreeServer* HTMLFrame::GetFrameTreeServer() {
-  // Prefer an ancestor with a FrameTreeServer.
+web_view::mojom::Frame* HTMLFrame::GetServerFrame() {
+  // Prefer an ancestor with a server Frame.
   for (HTMLFrame* frame = this; frame; frame = frame->parent_) {
     if (frame->server_.get())
       return frame->server_.get();
   }
 
   // No local root. This means we're a remote frame with no local frame
-  // ancestors. Use the local frame from the FrameTreeServer.
+  // ancestors. Use the server Frame from the local root of the
+  // HTMLFrameTreeManager.
   return frame_tree_manager_->local_root_->server_.get();
 }
 
 void HTMLFrame::SetView(mus::View* view) {
   if (view_)
     view_->RemoveObserver(this);
   view_ = view;
   if (view_)
     view_->AddObserver(this);
 }
@@ skipping 48 matching lines @@
   remote_frame->setRemoteWebLayer(web_layer_.get());
   remote_frame->setReplicatedName(state_.name);
   remote_frame->setReplicatedOrigin(state_.origin);
   remote_frame->setReplicatedSandboxFlags(state_.sandbox_flags);
   // Tell the frame that it is actually loading. This prevents its parent
   // from prematurely dispatching load event.
   remote_frame->didStartLoading();
   web_frame_ = remote_frame;
   SetView(nullptr);
   server_.reset();
-  frame_tree_client_binding_.reset();
+  frame_client_binding_.reset();
   if (delegate)
     delegate->OnFrameSwappedToRemote();
 }
 
 void HTMLFrame::SwapToLocal(
     HTMLFrameDelegate* delegate,
     mus::View* view,
     const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties) {
   CHECK(!IsLocal());
   // It doesn't make sense for the root to swap to local.
@@ skipping 92 matching lines @@
       event.To<scoped_ptr<blink::WebInputEvent>>();
   if (web_event)
     web_widget->handleInputEvent(*web_event);
 }
 
 void HTMLFrame::OnViewFocusChanged(mus::View* gained_focus,
                                    mus::View* lost_focus) {
   UpdateFocus();
 }
 
-void HTMLFrame::OnConnect(web_view::FrameTreeServerPtr server,
+void HTMLFrame::OnConnect(web_view::mojom::FramePtr frame,
                           uint32_t change_id,
                           uint32_t view_id,
-                          web_view::ViewConnectType view_connect_type,
-                          mojo::Array<web_view::FrameDataPtr> frame_data,
+                          web_view::mojom::ViewConnectType view_connect_type,
+                          mojo::Array<web_view::mojom::FrameDataPtr> frame_data,
                           const OnConnectCallback& callback) {
   // This is called if this frame is created by way of OnCreatedFrame().
   callback.Run();
 }
 
 void HTMLFrame::OnFrameAdded(uint32_t change_id,
-                             web_view::FrameDataPtr frame_data) {
+                             web_view::mojom::FrameDataPtr frame_data) {
   frame_tree_manager_->ProcessOnFrameAdded(this, change_id, frame_data.Pass());
 }
 
 void HTMLFrame::OnFrameRemoved(uint32_t change_id, uint32_t frame_id) {
   frame_tree_manager_->ProcessOnFrameRemoved(this, change_id, frame_id);
 }
 
 void HTMLFrame::OnFrameClientPropertyChanged(uint32_t frame_id,
                                              const mojo::String& name,
                                              mojo::Array<uint8_t> new_value) {
@@ skipping 115 matching lines @@
       global_state()->device_pixel_ratio(), rect_in_dip));
   const mojo::RectPtr mojo_rect_in_pixels(mojo::Rect::From(rect_in_pixels));
   view_->SetBounds(*mojo_rect_in_pixels);
 }
 
 void HTMLFrame::navigate(const blink::WebURLRequest& request,
                          bool should_replace_current_entry) {
   // TODO: support |should_replace_current_entry|.
   NOTIMPLEMENTED();  // for |should_replace_current_entry
   mojo::URLRequestPtr url_request = mojo::URLRequest::From(request);
-  GetFrameTreeServer()->RequestNavigate(
-      web_view::NAVIGATION_TARGET_TYPE_EXISTING_FRAME, id_, url_request.Pass());
+  GetServerFrame()->RequestNavigate(
+      web_view::mojom::NAVIGATION_TARGET_TYPE_EXISTING_FRAME, id_,
+      url_request.Pass());
 }
 
 void HTMLFrame::reload(bool ignore_cache, bool is_client_redirect) {
   NOTIMPLEMENTED();
 }
 
 void HTMLFrame::forwardInputEvent(const blink::WebInputEvent* event) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace mojo