blob: 15ee1116bd08419dec731f2188af7c35134d72dc [file] [log] [blame]
// Copyright 2016 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 "services/navigation/view_impl.h"
#include "base/strings/utf_string_conversions.h"
#include "components/mus/public/cpp/window_tree_client.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/interstitial_page.h"
#include "content/public/browser/interstitial_page_delegate.h"
#include "content/public/browser/navigation_controller.h"
#include "content/public/browser/navigation_details.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/notification_details.h"
#include "content/public/browser/notification_source.h"
#include "content/public/browser/notification_types.h"
#include "content/public/browser/web_contents.h"
#include "ui/views/controls/webview/webview.h"
#include "ui/views/mus/native_widget_mus.h"
#include "ui/views/widget/widget.h"
#include "url/gurl.h"
namespace navigation {
namespace {
class InterstitialPageDelegate : public content::InterstitialPageDelegate {
public:
explicit InterstitialPageDelegate(const std::string& html) : html_(html) {}
~InterstitialPageDelegate() override {}
InterstitialPageDelegate(const InterstitialPageDelegate&) = delete;
void operator=(const InterstitialPageDelegate&) = delete;
private:
// content::InterstitialPageDelegate:
std::string GetHTMLContents() override {
return html_;
}
const std::string html_;
};
// TODO(beng): Explicitly not writing a TypeConverter for this, and not doing a
// typemap just yet since I'm still figuring out what these
// interfaces should take as parameters.
mojom::NavigationEntryPtr EntryPtrFromNavEntry(
const content::NavigationEntry& entry) {
mojom::NavigationEntryPtr entry_ptr(mojom::NavigationEntry::New());
entry_ptr->id = entry.GetUniqueID();
entry_ptr->url = entry.GetURL();
entry_ptr->title = base::UTF16ToUTF8(entry.GetTitle());
entry_ptr->redirect_chain = entry.GetRedirectChain();
return entry_ptr;
}
} // namespace
ViewImpl::ViewImpl(shell::Connector* connector,
const std::string& client_user_id,
mojom::ViewClientPtr client,
mojom::ViewRequest request,
std::unique_ptr<shell::ShellConnectionRef> ref)
: connector_(connector),
binding_(this, std::move(request)),
client_(std::move(client)),
ref_(std::move(ref)),
web_view_(new views::WebView(
content::BrowserContext::GetBrowserContextForShellUserId(
client_user_id))) {
web_view_->GetWebContents()->SetDelegate(this);
const content::NavigationController* controller =
&web_view_->GetWebContents()->GetController();
registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
content::Source<content::NavigationController>(controller));
registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
content::Source<content::NavigationController>(controller));
registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
content::Source<content::NavigationController>(controller));
registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
content::Source<content::NavigationController>(controller));
}
ViewImpl::~ViewImpl() {}
void ViewImpl::NavigateTo(const GURL& url) {
web_view_->GetWebContents()->GetController().LoadURL(
url, content::Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
}
void ViewImpl::GoBack() {
web_view_->GetWebContents()->GetController().GoBack();
}
void ViewImpl::GoForward() {
web_view_->GetWebContents()->GetController().GoForward();
}
void ViewImpl::NavigateToOffset(int offset) {
web_view_->GetWebContents()->GetController().GoToOffset(offset);
}
void ViewImpl::Reload(bool skip_cache) {
if (skip_cache)
web_view_->GetWebContents()->GetController().Reload(true);
else
web_view_->GetWebContents()->GetController().ReloadBypassingCache(true);
}
void ViewImpl::Stop() {
web_view_->GetWebContents()->Stop();
}
void ViewImpl::GetWindowTreeClient(
mus::mojom::WindowTreeClientRequest request) {
new mus::WindowTreeClient(this, nullptr, std::move(request));
}
void ViewImpl::ShowInterstitial(const mojo::String& html) {
content::InterstitialPage* interstitial =
content::InterstitialPage::Create(web_view_->GetWebContents(),
false,
GURL(),
new InterstitialPageDelegate(html));
interstitial->Show();
}
void ViewImpl::HideInterstitial() {
// TODO(beng): this is not quite right.
if (web_view_->GetWebContents()->ShowingInterstitialPage())
web_view_->GetWebContents()->GetInterstitialPage()->Proceed();
}
void ViewImpl::SetResizerSize(const gfx::Size& size) {
resizer_size_ = size;
}
void ViewImpl::AddNewContents(content::WebContents* source,
content::WebContents* new_contents,
WindowOpenDisposition disposition,
const gfx::Rect& initial_rect,
bool user_gesture,
bool* was_blocked) {
mojom::ViewClientPtr client;
mojom::ViewPtr view;
mojom::ViewRequest view_request = GetProxy(&view);
client_->ViewCreated(std::move(view), GetProxy(&client),
disposition == NEW_POPUP, initial_rect, user_gesture);
const std::string new_user_id =
content::BrowserContext::GetShellUserIdFor(
new_contents->GetBrowserContext());
ViewImpl* impl = new ViewImpl(connector_, new_user_id, std::move(client),
std::move(view_request), ref_->Clone());
// TODO(beng): This is a bit crappy. should be able to create the ViewImpl
// with |new_contents| instead.
impl->web_view_->SetWebContents(new_contents);
impl->web_view_->GetWebContents()->SetDelegate(impl);
// TODO(beng): this reply is currently synchronous, figure out a fix.
if (was_blocked)
*was_blocked = false;
}
void ViewImpl::CloseContents(content::WebContents* source) {
client_->Close();
}
content::WebContents* ViewImpl::OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) {
mojom::OpenURLParamsPtr params_ptr = mojom::OpenURLParams::New();
params_ptr->url = params.url;
params_ptr->disposition =
static_cast<mojom::WindowOpenDisposition>(params.disposition);
client_->OpenURL(std::move(params_ptr));
// TODO(beng): Obviously this is the wrong thing to return for dispositions
// that would lead to the creation of a new View, i.e. NEW_TAB, NEW_POPUP etc.
// However it seems the callers of this function that we've seen so far
// disregard the return value. Rather than returning |source| I'm returning
// nullptr to locate (via crash) any sites that depend on a valid result.
// If we actually had to do this then we'd have to create the new WebContents
// here, store it with a cookie, and pass the cookie through to the client to
// pass back with their call to CreateView(), so it would get bound to the
// WebContents.
return nullptr;
}
void ViewImpl::LoadingStateChanged(content::WebContents* source,
bool to_different_document) {
client_->LoadingStateChanged(source->IsLoading());
}
void ViewImpl::NavigationStateChanged(content::WebContents* source,
content::InvalidateTypes changed_flags) {
client_->NavigationStateChanged(source->GetVisibleURL(),
base::UTF16ToUTF8(source->GetTitle()),
source->GetController().CanGoBack(),
source->GetController().CanGoForward());
}
void ViewImpl::LoadProgressChanged(content::WebContents* source,
double progress) {
client_->LoadProgressChanged(progress);
}
void ViewImpl::UpdateTargetURL(content::WebContents* source, const GURL& url) {
client_->UpdateHoverURL(url);
}
gfx::Rect ViewImpl::GetRootWindowResizerRect() const {
gfx::Rect bounds = web_view_->GetLocalBounds();
return gfx::Rect(bounds.right() - resizer_size_.width(),
bounds.bottom() - resizer_size_.height(),
resizer_size_.width(), resizer_size_.height());
}
void ViewImpl::Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) {
if (content::Source<content::NavigationController>(source).ptr() !=
&web_view_->GetWebContents()->GetController()) {
return;
}
switch (type) {
case content::NOTIFICATION_NAV_ENTRY_PENDING: {
const content::NavigationEntry* entry =
content::Details<content::NavigationEntry>(details).ptr();
client_->NavigationPending(EntryPtrFromNavEntry(*entry));
break;
}
case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
const content::LoadCommittedDetails* lcd =
content::Details<content::LoadCommittedDetails>(details).ptr();
mojom::NavigationCommittedDetailsPtr details_ptr(
mojom::NavigationCommittedDetails::New());
details_ptr->entry = lcd->entry->GetUniqueID();
details_ptr->type = static_cast<mojom::NavigationType>(lcd->type);
details_ptr->previous_entry_index = lcd->previous_entry_index;
details_ptr->previous_url = lcd->previous_url;
details_ptr->is_in_page = lcd->is_in_page;
details_ptr->is_main_frame = lcd->is_main_frame;
details_ptr->http_status_code = lcd->http_status_code;
client_->NavigationCommitted(
std::move(details_ptr),
web_view_->GetWebContents()->GetController().GetCurrentEntryIndex());
break;
}
case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
const content::EntryChangedDetails* ecd =
content::Details<content::EntryChangedDetails>(details).ptr();
client_->NavigationEntryChanged(EntryPtrFromNavEntry(*ecd->changed_entry),
ecd->index);
break;
}
case content::NOTIFICATION_NAV_LIST_PRUNED: {
const content::PrunedDetails* pd =
content::Details<content::PrunedDetails>(details).ptr();
client_->NavigationListPruned(pd->from_front, pd->count);
break;
}
default:
NOTREACHED();
break;
}
}
void ViewImpl::OnEmbed(mus::Window* root) {
DCHECK(!widget_.get());
widget_.reset(new views::Widget);
views::Widget::InitParams params(
views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
params.delegate = this;
params.native_widget = new views::NativeWidgetMus(
widget_.get(), connector_, root, mus::mojom::SurfaceType::DEFAULT);
widget_->Init(params);
widget_->Show();
}
void ViewImpl::OnWindowTreeClientDestroyed(mus::WindowTreeClient* client) {}
void ViewImpl::OnEventObserved(const ui::Event& event, mus::Window* target) {}
views::View* ViewImpl::GetContentsView() {
return web_view_;
}
views::Widget* ViewImpl::GetWidget() {
return web_view_->GetWidget();
}
const views::Widget* ViewImpl::GetWidget() const {
return web_view_->GetWidget();
}
} // navigation