Mandoline webview: 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"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/web_view/frame_tree.h"
 #include "components/web_view/frame_tree_delegate.h"
 #include "components/web_view/frame_user_data.h"
 #include "components/web_view/frame_utils.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "mojo/common/url_type_converters.h"
 #include "url/gurl.h"
 
 using mus::Window;
 
 DECLARE_WINDOW_PROPERTY_TYPE(web_view::Frame*);
 
 namespace web_view {
 
-// Used to find the Frame associated with a View.
+// Used to find the Frame associated with a Window.
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(Frame*, kFrame, nullptr);
 
 namespace {
 
 const uint32_t kNoParentId = 0u;
 const mus::ConnectionSpecificId kInvalidConnectionId = 0u;
 
 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::FrameUserDataAndBinding {
   scoped_ptr<FrameUserData> user_data;
   scoped_ptr<mojo::Binding<mojom::Frame>> frame_binding;
 };
 
 Frame::Frame(FrameTree* tree,
-             Window* view,
+             Window* window,
              uint32_t frame_id,
              uint32_t app_id,
-             ViewOwnership view_ownership,
+             WindowOwnership window_ownership,
              mojom::FrameClient* frame_client,
              scoped_ptr<FrameUserData> user_data,
              const ClientPropertyMap& client_properties)
     : tree_(tree),
-      view_(nullptr),
+      window_(nullptr),
       embedded_connection_id_(kInvalidConnectionId),
       id_(frame_id),
       app_id_(app_id),
       parent_(nullptr),
-      view_ownership_(view_ownership),
+      window_ownership_(window_ownership),
       user_data_(user_data.Pass()),
       frame_client_(frame_client),
       loading_(false),
       progress_(0.f),
       client_properties_(client_properties),
       waiting_for_on_will_navigate_ack_(false),
       embed_weak_ptr_factory_(this),
       navigate_weak_ptr_factory_(this) {
-  if (view)
-    SetView(view);
+  if (window)
+    SetWindow(window);
 }
 
 Frame::~Frame() {
   DVLOG(2) << "~Frame id=" << id_ << " this=" << this;
-  if (view_)
-    view_->RemoveObserver(this);
+  if (window_)
+    window_->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();
+  if (window_) {
+    window_->ClearLocalProperty(kFrame);
+    if (window_ownership_ == WindowOwnership::OWNS_WINDOW)
+      window_->Destroy();
   }
   tree_->delegate_->DidDestroyFrame(this);
 }
 
 void Frame::Init(Frame* parent,
                  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
@@ skipping 10 matching lines @@
   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) {
-  while (view && !view->GetLocalProperty(kFrame))
-    view = view->parent();
-  return view ? view->GetLocalProperty(kFrame) : nullptr;
+Frame* Frame::FindFirstFrameAncestor(Window* window) {
+  while (window && !window->GetLocalProperty(kFrame))
+    window = window->parent();
+  return window ? window->GetLocalProperty(kFrame) : nullptr;
 }
 
 const Frame* Frame::FindFrame(uint32_t id) const {
   if (id == id_)
     return this;
 
   for (const Frame* child : children_) {
     const Frame* match = child->FindFrame(id);
     if (match)
       return match;
@@ skipping 53 matching lines @@
 
 void Frame::InitClient(ClientType client_type,
                        scoped_ptr<FrameUserDataAndBinding> data_and_binding,
                        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 &&
       window_tree_client.get()) {
     embedded_connection_id_ = kInvalidConnectionId;
     embed_weak_ptr_factory_.InvalidateWeakPtrs();
-    view_->Embed(
+    window_->Embed(
         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 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,
+        nullptr, tree_->change_id(), id_, mojom::WINDOW_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 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,
+            ? mojom::WINDOW_CONNECT_TYPE_USE_EXISTING
+            : mojom::WINDOW_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();
   }
@@ skipping 50 matching lines @@
     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(), 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);
+void Frame::SetWindow(mus::Window* window) {
+  DCHECK(!window_);
+  DCHECK_EQ(id_, window->id());
+  window_ = window;
+  window_->SetLocalProperty(kFrame, this);
+  window_->AddObserver(this);
   if (pending_navigate_.get())
     StartNavigate(pending_navigate_.Pass());
 }
 
 void Frame::BuildFrameTree(std::vector<const Frame*>* frames) const {
   frames->push_back(this);
   for (const Frame* frame : children_)
     frame->BuildFrameTree(frames);
 }
 
@@ skipping 19 matching lines @@
 void Frame::StartNavigate(mojo::URLRequestPtr request) {
   if (waiting_for_on_will_navigate_ack_) {
     // We're waiting for OnWillNavigate(). We need to wait until that completes
     // before attempting any other loads.
     pending_navigate_ = request.Pass();
     return;
   }
 
   pending_navigate_.reset();
 
-  // We need a View to navigate. When we get the View we'll complete the
+  // We need a Window to navigate. When we get the Window we'll complete the
   // navigation.
-  if (!view_) {
+  if (!window_) {
     pending_navigate_ = request.Pass();
     return;
   }
 
   // Drop any pending navigation requests.
   navigate_weak_ptr_factory_.InvalidateWeakPtrs();
 
   DVLOG(2) << "Frame::StartNavigate id=" << id_ << " url=" << request->url;
 
   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,
     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 WindowTreeClient (because the app has a View
+    // case we do not use the WindowTreeClient (because the app has a Window
     // already
     // and ends up reusing it).
     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(window_tree_client.get());
     // TODO(sky): url isn't correct here, it should be a security origin.
     frame_client_->OnWillNavigate(
@@ skipping 40 matching lines @@
   frame_client_->OnFrameLoadingStateChanged(frame->id(), loading);
 }
 
 void Frame::NotifyDispatchFrameLoadEvent(const Frame* frame) {
   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);
+    if (child_frame && !child_frame->window_)
+      child_frame->SetWindow(params.target);
   }
 }
 
-void Frame::OnWindowDestroying(mus::Window* view) {
+void Frame::OnWindowDestroying(mus::Window* window) {
   if (parent_)
     parent_->Remove(this);
 
-  // Reset |view_ownership_| so we don't attempt to delete |view_| in the
+  // Reset |window_ownership_| so we don't attempt to delete |window_| in the
   // destructor.
-  view_ownership_ = ViewOwnership::DOESNT_OWN_VIEW;
+  window_ownership_ = WindowOwnership::DOESNT_OWN_WINDOW;
 
   if (tree_->root() == this) {
-    view_->RemoveObserver(this);
-    view_ = nullptr;
+    window_->RemoveObserver(this);
+    window_ = nullptr;
     return;
   }
 
   delete this;
 }
 
-void Frame::OnWindowEmbeddedAppDisconnected(mus::Window* view) {
+void Frame::OnWindowEmbeddedAppDisconnected(mus::Window* window) {
   // See FrameTreeDelegate::OnWindowEmbeddedAppDisconnected() for details of
   // when
   // 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_->OnWindowEmbeddedInFrameDisconnected(this);
 }
@@ skipping 116 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