Rename frame classes

components/web_view/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/web_view/frame.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 namespace web_view {
 
 // Used to find the Frame associated with a View.
 DEFINE_LOCAL_VIEW_PROPERTY_KEY(Frame*, kFrame, nullptr);
 
 namespace {
 
 const uint32_t kNoParentId = 0u;
 const mus::ConnectionSpecificId kInvalidConnectionId = 0u;
 
-FrameDataPtr FrameToFrameData(const Frame* frame) {
-  FrameDataPtr frame_data(FrameData::New());
+mojom::FrameDataPtr FrameToFrameData(const Frame* frame) {
+  mojom::FrameDataPtr frame_data(mojom::FrameData::New());
   frame_data->frame_id = frame->id();
   frame_data->parent_id = frame->parent() ? frame->parent()->id() : kNoParentId;
   frame_data->client_properties =
       mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(
           frame->client_properties());
   return frame_data.Pass();
 }
 
 }  // namespace
 
-struct Frame::FrameTreeServerBinding {
+struct Frame::FrameUserDataAndBinding {
   scoped_ptr<FrameUserData> user_data;
-  scoped_ptr<mojo::Binding<FrameTreeServer>> frame_tree_server_binding;
+  scoped_ptr<mojo::Binding<mojom::Frame>> frame_binding;
 };
 
 Frame::Frame(FrameTree* tree,
              View* view,
              uint32_t frame_id,
              uint32_t app_id,
              ViewOwnership view_ownership,
-             FrameTreeClient* frame_tree_client,
+             mojom::FrameClient* frame_client,
              scoped_ptr<FrameUserData> user_data,
              const ClientPropertyMap& client_properties)
     : tree_(tree),
       view_(nullptr),
       embedded_connection_id_(kInvalidConnectionId),
       id_(frame_id),
       app_id_(app_id),
       parent_(nullptr),
       view_ownership_(view_ownership),
       user_data_(user_data.Pass()),
-      frame_tree_client_(frame_tree_client),
+      frame_client_(frame_client),
       loading_(false),
       progress_(0.f),
       client_properties_(client_properties),
       embed_weak_ptr_factory_(this),
       navigate_weak_ptr_factory_(this) {
   if (view)
     SetView(view);
 }
 
 Frame::~Frame() {
   if (view_)
     view_->RemoveObserver(this);
   while (!children_.empty())
     delete children_[0];
   if (parent_)
     parent_->Remove(this);
   if (view_) {
     view_->ClearLocalProperty(kFrame);
     if (view_ownership_ == ViewOwnership::OWNS_VIEW)
       view_->Destroy();
   }
   tree_->delegate_->DidDestroyFrame(this);
 }
 
 void Frame::Init(Frame* parent,
                  mojo::ViewTreeClientPtr view_tree_client,
-                 mojo::InterfaceRequest<FrameTreeServer> server_request) {
+                 mojo::InterfaceRequest<mojom::Frame> frame_request) {
   {
-    // Set the FrameTreeClient to null so that we don't notify the client of the
+    // Set the FrameClient to null so that we don't notify the client of the
     // add before OnConnect().
-    base::AutoReset<FrameTreeClient*> frame_tree_client_resetter(
-        &frame_tree_client_, nullptr);
+    base::AutoReset<mojom::FrameClient*> frame_client_resetter(&frame_client_,
+                                                               nullptr);
     if (parent)
       parent->Add(this);
   }
 
-  const ClientType client_type = server_request.is_pending()
+  const ClientType client_type = frame_request.is_pending()
                                      ? ClientType::NEW_CHILD_FRAME
                                      : ClientType::EXISTING_FRAME_NEW_APP;
   InitClient(client_type, nullptr, view_tree_client.Pass(),
-             server_request.Pass());
+             frame_request.Pass());
 
   tree_->delegate_->DidCreateFrame(this);
 }
 
 // static
 Frame* Frame::FindFirstFrameAncestor(View* view) {
   while (view && !view->GetLocalProperty(kFrame))
     view = view->parent();
   return view ? view->GetLocalProperty(kFrame) : nullptr;
 }
@@ skipping 28 matching lines @@
 }
 
 double Frame::GatherProgress(int* frame_count) const {
   ++(*frame_count);
   double progress = progress_;
   for (const Frame* child : children_)
     progress += child->GatherProgress(frame_count);
   return progress_;
 }
 
-void Frame::InitClient(
-    ClientType client_type,
-    scoped_ptr<FrameTreeServerBinding> frame_tree_server_binding,
-    mojo::ViewTreeClientPtr view_tree_client,
-    mojo::InterfaceRequest<FrameTreeServer> server_request) {
+void Frame::InitClient(ClientType client_type,
+                       scoped_ptr<FrameUserDataAndBinding> data_and_binding,
+                       mojo::ViewTreeClientPtr view_tree_client,
+                       mojo::InterfaceRequest<mojom::Frame> frame_request) {
   if (client_type == ClientType::EXISTING_FRAME_NEW_APP &&
       view_tree_client.get()) {
     embedded_connection_id_ = kInvalidConnectionId;
     embed_weak_ptr_factory_.InvalidateWeakPtrs();
     view_->Embed(
         view_tree_client.Pass(), mojo::ViewTree::ACCESS_POLICY_DEFAULT,
         base::Bind(&Frame::OnEmbedAck, embed_weak_ptr_factory_.GetWeakPtr()));
   }
 
   if (client_type == ClientType::NEW_CHILD_FRAME) {
     // Don't install an error handler. We allow for the target to only
     // implement ViewTreeClient.
-    // This frame (and client) was created by an existing FrameTreeClient. There
+    // This frame (and client) was created by an existing FrameClient. There
     // is no need to send it OnConnect().
-    frame_tree_server_binding_.reset(
-        new mojo::Binding<FrameTreeServer>(this, server_request.Pass()));
-    frame_tree_client_->OnConnect(
-        nullptr, tree_->change_id(), id_, VIEW_CONNECT_TYPE_USE_NEW,
-        mojo::Array<FrameDataPtr>(),
-        base::Bind(&OnConnectAck, base::Passed(&frame_tree_server_binding)));
+    frame_binding_.reset(
+        new mojo::Binding<mojom::Frame>(this, frame_request.Pass()));
+    frame_client_->OnConnect(
+        nullptr, tree_->change_id(), id_, mojom::VIEW_CONNECT_TYPE_USE_NEW,
+        mojo::Array<mojom::FrameDataPtr>(),
+        base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
   } else {
     std::vector<const Frame*> frames;
     tree_->root()->BuildFrameTree(&frames);
 
-    mojo::Array<FrameDataPtr> array(frames.size());
+    mojo::Array<mojom::FrameDataPtr> array(frames.size());
     for (size_t i = 0; i < frames.size(); ++i)
       array[i] = FrameToFrameData(frames[i]).Pass();
 
-    FrameTreeServerPtr frame_tree_server_ptr;
+    mojom::FramePtr frame_ptr;
     // Don't install an error handler. We allow for the target to only
     // implement ViewTreeClient.
-    frame_tree_server_binding_.reset(new mojo::Binding<FrameTreeServer>(
-        this, GetProxy(&frame_tree_server_ptr).Pass()));
-    frame_tree_client_->OnConnect(
-        frame_tree_server_ptr.Pass(), tree_->change_id(), id_,
+    frame_binding_.reset(
+        new mojo::Binding<mojom::Frame>(this, GetProxy(&frame_ptr).Pass()));
+    frame_client_->OnConnect(
+        frame_ptr.Pass(), tree_->change_id(), id_,
         client_type == ClientType::EXISTING_FRAME_SAME_APP
-            ? VIEW_CONNECT_TYPE_USE_EXISTING
-            : VIEW_CONNECT_TYPE_USE_NEW,
+            ? mojom::VIEW_CONNECT_TYPE_USE_EXISTING
+            : mojom::VIEW_CONNECT_TYPE_USE_NEW,
         array.Pass(),
-        base::Bind(&OnConnectAck, base::Passed(&frame_tree_server_binding)));
+        base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
     tree_->delegate_->DidStartNavigation(this);
   }
 }
 
 // static
-void Frame::OnConnectAck(
-    scoped_ptr<FrameTreeServerBinding> frame_tree_server_binding) {}
+void Frame::OnConnectAck(scoped_ptr<FrameUserDataAndBinding> data_and_binding) {
+}
 
-void Frame::ChangeClient(FrameTreeClient* frame_tree_client,
+void Frame::ChangeClient(mojom::FrameClient* frame_client,
                          scoped_ptr<FrameUserData> user_data,
                          mojo::ViewTreeClientPtr view_tree_client,
                          uint32_t app_id) {
   while (!children_.empty())
     delete children_[0];
 
   ClientType client_type = view_tree_client.get() == nullptr
                                ? ClientType::EXISTING_FRAME_SAME_APP
                                : ClientType::EXISTING_FRAME_NEW_APP;
-  scoped_ptr<FrameTreeServerBinding> frame_tree_server_binding;
+  scoped_ptr<FrameUserDataAndBinding> data_and_binding;
 
   if (client_type == ClientType::EXISTING_FRAME_SAME_APP) {
     // See comment in InitClient() for details.
-    frame_tree_server_binding.reset(new FrameTreeServerBinding);
-    frame_tree_server_binding->user_data = user_data_.Pass();
-    frame_tree_server_binding->frame_tree_server_binding =
-        frame_tree_server_binding_.Pass();
+    data_and_binding.reset(new FrameUserDataAndBinding);
+    data_and_binding->user_data = user_data_.Pass();
+    data_and_binding->frame_binding = frame_binding_.Pass();
   } else {
     loading_ = false;
     progress_ = 0.f;
   }
 
   user_data_ = user_data.Pass();
-  frame_tree_client_ = frame_tree_client;
-  frame_tree_server_binding_.reset();
+  frame_client_ = frame_client;
+  frame_binding_.reset();
   app_id_ = app_id;
 
-  InitClient(client_type, frame_tree_server_binding.Pass(),
-             view_tree_client.Pass(), nullptr);
+  InitClient(client_type, data_and_binding.Pass(), view_tree_client.Pass(),
+             nullptr);
 }
 
 void Frame::OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id) {
   if (success)
     embedded_connection_id_ = connection_id;
 }
 
 void Frame::SetView(mus::View* view) {
   DCHECK(!view_);
   DCHECK_EQ(id_, view->id());
@@ skipping 42 matching lines @@
   // Drop any pending navigation requests.
   navigate_weak_ptr_factory_.InvalidateWeakPtrs();
 
   tree_->delegate_->CanNavigateFrame(
       this, request.Pass(),
       base::Bind(&Frame::OnCanNavigateFrame,
                  navigate_weak_ptr_factory_.GetWeakPtr()));
 }
 
 void Frame::OnCanNavigateFrame(uint32_t app_id,
-                               FrameTreeClient* frame_tree_client,
+                               mojom::FrameClient* frame_client,
                                scoped_ptr<FrameUserData> user_data,
                                mojo::ViewTreeClientPtr view_tree_client) {
   if (AreAppIdsEqual(app_id, app_id_)) {
     // The app currently rendering the frame will continue rendering it. In this
     // case we do not use the ViewTreeClient (because the app has a View already
     // and ends up reusing it).
     DCHECK(!view_tree_client.get());
   } else {
-    frame_tree_client_->OnWillNavigate();
+    frame_client_->OnWillNavigate();
     DCHECK(view_tree_client.get());
   }
-  ChangeClient(frame_tree_client, user_data.Pass(), view_tree_client.Pass(),
-               app_id);
+  ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(), app_id);
 }
 
 void Frame::NotifyAdded(const Frame* source,
                         const Frame* added_node,
                         uint32_t change_id) {
-  // |frame_tree_client_| may be null during initial frame creation and
-  // parenting.
-  if (frame_tree_client_)
-    frame_tree_client_->OnFrameAdded(change_id, FrameToFrameData(added_node));
+  // |frame_client_| may be null during initial frame creation and parenting.
+  if (frame_client_)
+    frame_client_->OnFrameAdded(change_id, FrameToFrameData(added_node));
 
   for (Frame* child : children_)
     child->NotifyAdded(source, added_node, change_id);
 }
 
 void Frame::NotifyRemoved(const Frame* source,
                           const Frame* removed_node,
                           uint32_t change_id) {
-  frame_tree_client_->OnFrameRemoved(change_id, removed_node->id());
+  frame_client_->OnFrameRemoved(change_id, removed_node->id());
 
   for (Frame* child : children_)
     child->NotifyRemoved(source, removed_node, change_id);
 }
 
 void Frame::NotifyClientPropertyChanged(const Frame* source,
                                         const mojo::String& name,
                                         const mojo::Array<uint8_t>& value) {
   if (this != source)
-    frame_tree_client_->OnFrameClientPropertyChanged(source->id(), name,
-                                                     value.Clone());
+    frame_client_->OnFrameClientPropertyChanged(source->id(), name,
+                                                value.Clone());
 
   for (Frame* child : children_)
     child->NotifyClientPropertyChanged(source, name, value);
 }
 
 void Frame::NotifyFrameLoadingStateChanged(const Frame* frame, bool loading) {
-  frame_tree_client_->OnFrameLoadingStateChanged(frame->id(), loading);
+  frame_client_->OnFrameLoadingStateChanged(frame->id(), loading);
 }
 
 void Frame::NotifyDispatchFrameLoadEvent(const Frame* frame) {
-  frame_tree_client_->OnDispatchFrameLoadEvent(frame->id());
+  frame_client_->OnDispatchFrameLoadEvent(frame->id());
 }
 
 void Frame::OnTreeChanged(const TreeChangeParams& params) {
   if (params.new_parent && this == tree_->root()) {
     Frame* child_frame = FindFrame(params.target->id());
     if (child_frame && !child_frame->view_)
       child_frame->SetView(params.target);
   }
 }
 
@@ skipping 19 matching lines @@
   // this happens.
   //
   // Currently we have no way to distinguish between the cases that lead to this
   // being called, so we assume we can continue on. Continuing on is important
   // for html as it's entirely possible for a page to create a frame, navigate
   // to a bogus url and expect the frame to still exist.
   tree_->delegate_->OnViewEmbeddedInFrameDisconnected(this);
 }
 
 void Frame::PostMessageEventToFrame(uint32_t target_frame_id,
-                                    HTMLMessageEventPtr event) {
+                                    mojom::HTMLMessageEventPtr event) {
   // NOTE: |target_frame_id| is allowed to be from another connection.
   Frame* target = tree_->root()->FindFrame(target_frame_id);
   if (!target || target == this ||
       !tree_->delegate_->CanPostMessageEventToFrame(this, target, event.get()))
     return;
 
-  target->frame_tree_client_->OnPostMessageEvent(id_, target_frame_id,
-                                                 event.Pass());
+  target->frame_client_->OnPostMessageEvent(id_, target_frame_id, event.Pass());
 }
 
 void Frame::LoadingStateChanged(bool loading, double progress) {
   bool loading_state_changed = loading_ != loading;
   loading_ = loading;
   progress_ = progress;
   tree_->LoadingStateChanged();
 
   if (loading_state_changed && parent_ &&
       !AreAppIdsEqual(app_id_, parent_->app_id_)) {
@@ skipping 26 matching lines @@
   } else {
     std::vector<uint8_t> as_vector(value.To<std::vector<uint8_t>>());
     if (already_in_map && iter->second == as_vector)
       return;
     client_properties_[name] = as_vector;
   }
   tree_->ClientPropertyChanged(this, name, value);
 }
 
 void Frame::OnCreatedFrame(
-    mojo::InterfaceRequest<FrameTreeServer> server_request,
-    FrameTreeClientPtr client,
+    mojo::InterfaceRequest<mojom::Frame> frame_request,
+    mojom::FrameClientPtr client,
     uint32_t frame_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties) {
   if ((frame_id >> 16) != embedded_connection_id_) {
     // TODO(sky): kill connection here?
     // TODO(sky): there is a race in that there is no guarantee we received the
     // connection id before the frame tries to create a new frame. Ideally we
     // could pause the frame until we get the connection id, but bindings don't
     // offer such an API.
     DVLOG(1) << "OnCreatedFrame supplied invalid frame id, expecting"
              << embedded_connection_id_;
     return;
   }
 
   if (FindFrame(frame_id)) {
     // TODO(sky): kill connection here?
     DVLOG(1) << "OnCreatedFrame supplied id of existing frame.";
     return;
   }
 
   Frame* child_frame = tree_->CreateChildFrame(
-      this, server_request.Pass(), client.Pass(), frame_id, app_id_,
+      this, frame_request.Pass(), client.Pass(), frame_id, app_id_,
       client_properties.To<ClientPropertyMap>());
   child_frame->embedded_connection_id_ = embedded_connection_id_;
 }
 
-void Frame::RequestNavigate(NavigationTargetType target_type,
+void Frame::RequestNavigate(mojom::NavigationTargetType target_type,
                             uint32_t target_frame_id,
                             mojo::URLRequestPtr request) {
-  if (target_type == NAVIGATION_TARGET_TYPE_EXISTING_FRAME) {
+  if (target_type == mojom::NAVIGATION_TARGET_TYPE_EXISTING_FRAME) {
     // |target_frame| is allowed to come from another connection.
     Frame* target_frame = tree_->root()->FindFrame(target_frame_id);
     if (!target_frame) {
       DVLOG(1) << "RequestNavigate EXISTING_FRAME with no matching frame";
       return;
     }
     if (target_frame != tree_->root()) {
       target_frame->StartNavigate(request.Pass());
       return;
     }
@@ skipping 10 matching lines @@
   if (parent_ && !AreAppIdsEqual(app_id_, parent_->app_id_)) {
     // Send notification to fire a load event in the parent, if the parent is in
     // a different app. If the parent is in the same app, we assume that the app
     // itself handles firing load event directly and no notification is needed
     // from our side.
     parent_->NotifyDispatchFrameLoadEvent(this);
   }
 }
 
 }  // namespace web_view