components/mus/public/interfaces View => Window

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 77 matching lines @@
     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,
+                 mus::mojom::WindowTreeClientPtr window_tree_client,
                  mojo::InterfaceRequest<mojom::Frame> frame_request,
                  base::TimeTicks navigation_start_time) {
   {
     // Set the FrameClient to null so that we don't notify the client of the
     // add before OnConnect().
     base::AutoReset<mojom::FrameClient*> frame_client_resetter(&frame_client_,
                                                                nullptr);
     if (parent)
       parent->Add(this);
   }
 
   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(),
+  InitClient(client_type, nullptr, window_tree_client.Pass(),
              frame_request.Pass(), navigation_start_time);
 
   tree_->delegate_->DidCreateFrame(this);
 
   DVLOG(2) << "Frame id=" << id_ << " parent=" << (parent_ ? parent_->id_ : 0)
            << " app_id=" << app_id_ << " this=" << this;
 }
 
 // static
 Frame* Frame::FindFirstFrameAncestor(Window* view) {
@@ skipping 59 matching lines @@
   frame_client_->HighlightFindResults(request_id, search_text, options.Pass(),
                                       reset);
 }
 
 void Frame::StopHighlightingFindResults() {
   frame_client_->StopHighlightingFindResults();
 }
 
 void Frame::InitClient(ClientType client_type,
                        scoped_ptr<FrameUserDataAndBinding> data_and_binding,
-                       mojo::ViewTreeClientPtr view_tree_client,
+                       mus::mojom::WindowTreeClientPtr window_tree_client,
                        mojo::InterfaceRequest<mojom::Frame> frame_request,
                        base::TimeTicks navigation_start_time) {
   if (client_type == ClientType::EXISTING_FRAME_NEW_APP &&
-      view_tree_client.get()) {
+      window_tree_client.get()) {
     embedded_connection_id_ = kInvalidConnectionId;
     embed_weak_ptr_factory_.InvalidateWeakPtrs();
     view_->Embed(
-        view_tree_client.Pass(), mojo::ViewTree::ACCESS_POLICY_DEFAULT,
+        window_tree_client.Pass(),
+        mus::mojom::WindowTree::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.
+    // implement WindowTreeClient.
     // This frame (and client) was created by an existing FrameClient. There
     // is no need to send it OnConnect().
     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>(),
         navigation_start_time.ToInternalValue(),
         base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
   } else {
     std::vector<const Frame*> frames;
     tree_->root()->BuildFrameTree(&frames);
 
     mojo::Array<mojom::FrameDataPtr> array(frames.size());
     for (size_t i = 0; i < frames.size(); ++i)
       array[i] = FrameToFrameData(frames[i]).Pass();
 
     mojom::FramePtr frame_ptr;
     // Don't install an error handler. We allow for the target to only
-    // implement ViewTreeClient.
+    // implement WindowTreeClient.
     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
             ? mojom::VIEW_CONNECT_TYPE_USE_EXISTING
             : mojom::VIEW_CONNECT_TYPE_USE_NEW,
         array.Pass(), navigation_start_time.ToInternalValue(),
         base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
     tree_->delegate_->DidStartNavigation(this);
 
     // We need |embedded_connection_id_| is order to validate requests to
     // create a child frame (OnCreatedFrame()). Pause incoming methods until
     // we get the id to prevent race conditions.
     if (embedded_connection_id_ == kInvalidConnectionId)
       frame_binding_->PauseIncomingMethodCallProcessing();
   }
 }
 
 // static
 void Frame::OnConnectAck(scoped_ptr<FrameUserDataAndBinding> data_and_binding) {
 }
 
 void Frame::ChangeClient(mojom::FrameClient* frame_client,
                          scoped_ptr<FrameUserData> user_data,
-                         mojo::ViewTreeClientPtr view_tree_client,
+                         mus::mojom::WindowTreeClientPtr window_tree_client,
                          uint32_t app_id,
                          base::TimeTicks navigation_start_time) {
   while (!children_.empty())
     delete children_[0];
 
-  ClientType client_type = view_tree_client.get() == nullptr
+  ClientType client_type = window_tree_client.get() == nullptr
                                ? ClientType::EXISTING_FRAME_SAME_APP
                                : ClientType::EXISTING_FRAME_NEW_APP;
   scoped_ptr<FrameUserDataAndBinding> data_and_binding;
 
   if (client_type == ClientType::EXISTING_FRAME_SAME_APP) {
     // See comment in InitClient() for details.
     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_client_ = frame_client;
   frame_binding_.reset();
   app_id_ = app_id;
 
-  InitClient(client_type, data_and_binding.Pass(), view_tree_client.Pass(),
+  InitClient(client_type, data_and_binding.Pass(), window_tree_client.Pass(),
              nullptr, navigation_start_time);
 }
 
 void Frame::OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id) {
   if (success)
     embedded_connection_id_ = connection_id;
   if (frame_binding_->is_bound())
     frame_binding_->ResumeIncomingMethodCallProcessing();
 }
 
-void Frame::OnWillNavigateAck(mojom::FrameClient* frame_client,
-                              scoped_ptr<FrameUserData> user_data,
-                              mojo::ViewTreeClientPtr view_tree_client,
-                              uint32 app_id,
-                              base::TimeTicks navigation_start_time) {
+void Frame::OnWillNavigateAck(
+    mojom::FrameClient* frame_client,
+    scoped_ptr<FrameUserData> user_data,
+    mus::mojom::WindowTreeClientPtr window_tree_client,
+    uint32 app_id,
+    base::TimeTicks navigation_start_time) {
   DCHECK(waiting_for_on_will_navigate_ack_);
   DVLOG(2) << "Frame::OnWillNavigateAck id=" << id_;
   waiting_for_on_will_navigate_ack_ = false;
-  ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(), app_id,
-               navigation_start_time);
+  ChangeClient(frame_client, user_data.Pass(), window_tree_client.Pass(),
+               app_id, navigation_start_time);
   if (pending_navigate_.get())
     StartNavigate(pending_navigate_.Pass());
 }
 
 void Frame::SetView(mus::Window* view) {
   DCHECK(!view_);
   DCHECK_EQ(id_, view->id());
   view_ = view;
   view_->SetLocalProperty(kFrame, this);
   view_->AddObserver(this);
@@ skipping 50 matching lines @@
 
   const GURL requested_url(request->url);
   base::TimeTicks navigation_start_time =
       base::TimeTicks::FromInternalValue(request->originating_time_ticks);
   tree_->delegate_->CanNavigateFrame(
       this, request.Pass(), base::Bind(&Frame::OnCanNavigateFrame,
                                        navigate_weak_ptr_factory_.GetWeakPtr(),
                                        requested_url, navigation_start_time));
 }
 
-void Frame::OnCanNavigateFrame(const GURL& url,
-                               base::TimeTicks navigation_start_time,
-                               uint32_t app_id,
-                               mojom::FrameClient* frame_client,
-                               scoped_ptr<FrameUserData> user_data,
-                               mojo::ViewTreeClientPtr view_tree_client) {
+void Frame::OnCanNavigateFrame(
+    const GURL& url,
+    base::TimeTicks navigation_start_time,
+    uint32_t app_id,
+    mojom::FrameClient* frame_client,
+    scoped_ptr<FrameUserData> user_data,
+    mus::mojom::WindowTreeClientPtr window_tree_client) {
   DVLOG(2) << "Frame::OnCanNavigateFrame id=" << id_
            << " equal=" << (AreAppIdsEqual(app_id, app_id_) ? "true" : "false");
   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
+    // case we do not use the WindowTreeClient (because the app has a View
+    // already
     // and ends up reusing it).
-    DCHECK(!view_tree_client.get());
-    ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(),
+    DCHECK(!window_tree_client.get());
+    ChangeClient(frame_client, user_data.Pass(), window_tree_client.Pass(),
                  app_id, navigation_start_time);
   } else {
     waiting_for_on_will_navigate_ack_ = true;
-    DCHECK(view_tree_client.get());
+    DCHECK(window_tree_client.get());
     // TODO(sky): url isn't correct here, it should be a security origin.
     frame_client_->OnWillNavigate(
         url.spec(),
         base::Bind(&Frame::OnWillNavigateAck, base::Unretained(this),
                    frame_client, base::Passed(&user_data),
-                   base::Passed(&view_tree_client), app_id,
+                   base::Passed(&window_tree_client), app_id,
                    navigation_start_time));
   }
 }
 
 void Frame::NotifyAdded(const Frame* source,
                         const Frame* added_node,
                         uint32_t change_id) {
   // |frame_client_| may be null during initial frame creation and parenting.
   if (frame_client_)
     frame_client_->OnFrameAdded(change_id, FrameToFrameData(added_node));
@@ skipping 185 matching lines @@
                                               final_update);
 }
 
 void Frame::OnFindInPageSelectionUpdated(int32_t request_id,
                                          int32_t active_match_ordinal) {
   tree_->delegate_->OnFindInPageSelectionUpdated(request_id, this,
                                                  active_match_ordinal);
 }
 
 }  // namespace web_view