More html_viewer OOPIF changes

components/html_viewer/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/frame.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/html_viewer/ax_provider_impl.h"
+#include "components/html_viewer/blink_basic_type_converters.h"
 #include "components/html_viewer/blink_input_events_type_converters.h"
 #include "components/html_viewer/blink_url_request_type_converters.h"
 #include "components/html_viewer/frame_tree_manager.h"
 #include "components/html_viewer/geolocation_client_impl.h"
 #include "components/html_viewer/global_state.h"
 #include "components/html_viewer/media_factory.h"
 #include "components/html_viewer/touch_handler.h"
 #include "components/html_viewer/web_layer_impl.h"
 #include "components/html_viewer/web_layer_tree_view_impl.h"
 #include "components/html_viewer/web_storage_namespace_impl.h"
@@ skipping 63 matching lines @@
       view_(nullptr),
       id_(params.id),
       web_frame_(nullptr),
       web_widget_(nullptr),
       scope_(blink::WebTreeScopeType::Document),
       weak_factory_(this) {
   if (parent_)
     parent_->children_.push_back(this);
 }
 
-void Frame::Init(mojo::View* local_view) {
-  // TODO(sky): need to plumb through scope, name and other args correctly for
-  // frame creation.
+void Frame::Init(mojo::View* local_view,
+                 const blink::WebString& remote_frame_name,
+                 const blink::WebString& remote_origin) {
+  if (local_view->id() == id_)
+    SetView(local_view);
+
+  // TODO(sky): need to plumb through scope and other args correctly for frame
+  // creation.
   if (!parent_) {
     CreateWebWidget();
     // This is the root of the tree (aka the main frame).
     // Expected order for creating webframes is:
     // . Create local webframe (first webframe must always be local).
     // . Set as main frame on WebView.
     // . Swap to remote (if not local).
     blink::WebLocalFrame* local_web_frame =
         blink::WebLocalFrame::create(blink::WebTreeScopeType::Document, this);
     // We need to set the main frame before creating children so that state is
     // properly set up in blink.
     // TODO(sky): I don't like these casts.
     web_view()->setMainFrame(local_web_frame);
     const gfx::Size size_in_pixels(local_view->bounds().width,
                                    local_view->bounds().height);
     const gfx::Size size_in_dips = gfx::ConvertSizeToDIP(
         local_view->viewport_metrics().device_pixel_ratio, size_in_pixels);
     web_widget_->resize(size_in_dips);
     web_frame_ = local_web_frame;
     web_view()->setDeviceScaleFactor(global_state()->device_pixel_ratio());
     if (id_ != local_view->id()) {
       blink::WebRemoteFrame* remote_web_frame = blink::WebRemoteFrame::create(
           blink::WebTreeScopeType::Document, this);
       local_web_frame->swap(remote_web_frame);
       // local_web_frame->close();
       web_frame_ = remote_web_frame;
-      // TODO(sky): This needs to come from FrameTreeData.
-      remote_web_frame->setReplicatedOrigin(
-          blink::WebSecurityOrigin::createFromString(""));
     }
   } else if (id_ == local_view->id()) {
     // Frame represents the local frame.
     Frame* previous_sibling = GetPreviousSibling(this);
     blink::WebFrame* previous_web_frame =
         previous_sibling ? previous_sibling->web_frame() : nullptr;
     DCHECK(!parent_->IsLocal());
     web_frame_ = parent_->web_frame()->toWebRemoteFrame()->createLocalChild(
         blink::WebTreeScopeType::Document, "", blink::WebSandboxFlags::None,
         this, previous_web_frame);
     CreateWebWidget();
   } else if (parent_->web_frame()->isWebLocalFrame()) {
     blink::WebLocalFrame* local_web_frame =
         blink::WebLocalFrame::create(blink::WebTreeScopeType::Document, this);
     parent_->web_frame()->appendChild(local_web_frame);
     blink::WebRemoteFrame* remote_web_frame =
         blink::WebRemoteFrame::create(blink::WebTreeScopeType::Document, this);
     // remote_web_frame->swap(local_web_frame);
     local_web_frame->close();
     web_frame_ = remote_web_frame;
   } else {
     web_frame_ = parent_->web_frame()->toWebRemoteFrame()->createRemoteChild(
-        blink::WebTreeScopeType::Document, "", blink::WebSandboxFlags::None,
-        this);
+        blink::WebTreeScopeType::Document, remote_frame_name,
+        blink::WebSandboxFlags::None, this);
+  }
+
+  if (!IsLocal()) {
+    blink::WebRemoteFrame* remote_web_frame = web_frame_->toWebRemoteFrame();
+    if (remote_web_frame) {
+      remote_web_frame->setReplicatedName(remote_frame_name);
+      remote_web_frame->setReplicatedOrigin(
+          blink::WebSecurityOrigin::createFromString(remote_origin));
+    }
   }
 }
 
 void Frame::Close() {
   if (web_widget_) {
     // Closing the widget implicitly detaches the frame.
     web_widget_->close();
   } else {
     web_frame_->detach();
   }
@@ skipping 28 matching lines @@
   parent_ = nullptr;
 
   frame_tree_manager_->OnFrameDestroyed(this);
 
   if (view_) {
     view_->RemoveObserver(this);
     view_->Destroy();
   }
 }
 
+void Frame::SetRemoteFrameName(const mojo::String& name) {
+  if (IsLocal())
+    return;
+
+  blink::WebRemoteFrame* remote_frame = web_frame_->toWebRemoteFrame();
+  if (remote_frame)
+    remote_frame->setReplicatedName(name.To<blink::WebString>());
+}
+
 bool Frame::IsLocal() const {
   return web_frame_->isWebLocalFrame();
 }
 
 void Frame::SetView(mojo::View* view) {
   DCHECK(!view_);
   view_ = view;
   view_->AddObserver(this);
 }
 
@@ skipping 271 matching lines @@
 }
 
 void Frame::didStopLoading() {
   frame_tree_manager_->LoadingStopped();
 }
 
 void Frame::didChangeLoadProgress(double load_progress) {
   frame_tree_manager_->ProgressChanged(load_progress);
 }
 
+void Frame::didChangeName(blink::WebLocalFrame* frame,
+                          const blink::WebString& name) {
+  frame_tree_manager_->OnFrameDidChangeName(this, name);
+}
+
 void Frame::frameDetached(blink::WebRemoteFrameClient::DetachType type) {
   if (type == blink::WebRemoteFrameClient::DetachType::Swap) {
     web_frame_->close();
     return;
   }
 
   DCHECK(type == blink::WebRemoteFrameClient::DetachType::Remove);
   FrameDetachedImpl(web_frame_);
 }
 
@@ skipping 22 matching lines @@
 
 void Frame::reload(bool ignore_cache, bool is_client_redirect) {
   NOTIMPLEMENTED();
 }
 
 void Frame::forwardInputEvent(const blink::WebInputEvent* event) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace mojo