Move HTMLViewer out of mojo namespace

mojo/services/html_viewer/html_document.cc

 // Copyright 2014 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 "mojo/services/html_viewer/html_document.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 20 matching lines @@
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
-namespace mojo {
+using mojo::AxProvider;
+using mojo::Rect;
+using mojo::ServiceProviderPtr;
+using mojo::URLResponsePtr;
+using mojo::View;
+using mojo::ViewManager;
+
+namespace html_viewer {
 namespace {
 
 void ConfigureSettings(blink::WebSettings* settings) {
   settings->setCookieEnabled(true);
   settings->setDefaultFixedFontSize(13);
   settings->setDefaultFontSize(16);
   settings->setLoadsImagesAutomatically(true);
   settings->setJavaScriptEnabled(true);
 }
 
-Target WebNavigationPolicyToNavigationTarget(
+mojo::Target WebNavigationPolicyToNavigationTarget(
     blink::WebNavigationPolicy policy) {
   switch (policy) {
     case blink::WebNavigationPolicyCurrentTab:
-      return TARGET_SOURCE_NODE;
+      return mojo::TARGET_SOURCE_NODE;
     case blink::WebNavigationPolicyNewBackgroundTab:
     case blink::WebNavigationPolicyNewForegroundTab:
     case blink::WebNavigationPolicyNewWindow:
     case blink::WebNavigationPolicyNewPopup:
-      return TARGET_NEW_NODE;
+      return mojo::TARGET_NEW_NODE;
     default:
-      return TARGET_DEFAULT;
+      return mojo::TARGET_DEFAULT;
   }
 }
 
 bool CanNavigateLocally(blink::WebFrame* frame,
                         const blink::WebURLRequest& request) {
   // For now, we just load child frames locally.
   // TODO(aa): In the future, this should use embedding to connect to a
   // different instance of Blink if the frame is cross-origin.
   if (frame->parent())
     return true;
 
   // If we have extraData() it means we already have the url response
   // (presumably because we are being called via Navigate()). In that case we
   // can go ahead and navigate locally.
   if (request.extraData())
     return true;
 
   // Otherwise we don't know if we're the right app to handle this request. Ask
   // host to do the navigation for us.
   return false;
 }
 
 }  // namespace
 
 HTMLDocument::HTMLDocument(
     mojo::ServiceProviderPtr provider,
     URLResponsePtr response,
-    Shell* shell,
+    mojo::Shell* shell,
     scoped_refptr<base::MessageLoopProxy> compositor_thread,
     WebMediaPlayerFactory* web_media_player_factory)
     : response_(response.Pass()),
       shell_(shell),
       web_view_(NULL),
       root_(NULL),
       view_manager_client_factory_(shell_, this),
       compositor_thread_(compositor_thread),
       web_media_player_factory_(web_media_player_factory) {
   exported_services_.AddService(this);
   exported_services_.AddService(&view_manager_client_factory_);
   WeakBindToPipe(&exported_services_, provider.PassMessagePipe());
   Load(response_.Pass());
 }
 
 HTMLDocument::~HTMLDocument() {
   STLDeleteElements(&ax_provider_impls_);
 
   if (web_view_)
     web_view_->close();
   if (root_)
     root_->RemoveObserver(this);
 }
 
 void HTMLDocument::OnEmbed(
     ViewManager* view_manager,
     View* root,
-    ServiceProviderImpl* embedee_service_provider_impl,
-    scoped_ptr<ServiceProvider> embedder_service_provider) {
+    mojo::ServiceProviderImpl* embedee_service_provider_impl,
+    scoped_ptr<mojo::ServiceProvider> embedder_service_provider) {
   root_ = root;
   embedder_service_provider_ = embedder_service_provider.Pass();
   navigator_host_.set_service_provider(embedder_service_provider_.get());
 
   blink::WebSize root_size(root_->bounds().width, root_->bounds().height);
   web_view_->resize(root_size);
   web_layer_tree_view_impl_->setViewportSize(root_size);
   web_layer_tree_view_impl_->set_view(root_);
   root_->AddObserver(this);
 }
 
-void HTMLDocument::Create(ApplicationConnection* connection,
-                          InterfaceRequest<AxProvider> request) {
+void HTMLDocument::Create(mojo::ApplicationConnection* connection,
+                          mojo::InterfaceRequest<AxProvider> request) {
   if (!web_view_)
     return;
   ax_provider_impls_.insert(
       WeakBindToRequest(new AxProviderImpl(web_view_), &request));
 }
 
 void HTMLDocument::OnViewManagerDisconnected(ViewManager* view_manager) {
   // TODO(aa): Need to figure out how shutdown works.
 }
 
@@ skipping 17 matching lines @@
 }
 
 blink::WebStorageNamespace* HTMLDocument::createSessionStorageNamespace() {
   return new WebStorageNamespaceImpl();
 }
 
 void HTMLDocument::initializeLayerTreeView() {
   ServiceProviderPtr surfaces_service_provider;
   shell_->ConnectToApplication("mojo:surfaces_service",
                                GetProxy(&surfaces_service_provider));
-  SurfacesServicePtr surfaces_service;
+  mojo::SurfacesServicePtr surfaces_service;
   ConnectToService(surfaces_service_provider.get(), &surfaces_service);
 
   ServiceProviderPtr gpu_service_provider;
   // TODO(jamesr): Should be mojo:gpu_service
   shell_->ConnectToApplication("mojo:native_viewport_service",
                                GetProxy(&gpu_service_provider));
-  GpuPtr gpu_service;
+  mojo::GpuPtr gpu_service;
   ConnectToService(gpu_service_provider.get(), &gpu_service);
   web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
       compositor_thread_, surfaces_service.Pass(), gpu_service.Pass()));
 }
 
 blink::WebLayerTreeView* HTMLDocument::layerTreeView() {
   return web_layer_tree_view_impl_.get();
 }
 
 blink::WebMediaPlayer* HTMLDocument::createMediaPlayer(
@@ skipping 39 matching lines @@
     blink::WebDataSource::ExtraData* data,
     const blink::WebURLRequest& request,
     blink::WebNavigationType nav_type,
     blink::WebNavigationPolicy default_policy,
     bool is_redirect) {
   if (CanNavigateLocally(frame, request))
     return default_policy;
 
   navigator_host_->RequestNavigate(
       WebNavigationPolicyToNavigationTarget(default_policy),
-      URLRequest::From(request).Pass());
+      mojo::URLRequest::From(request).Pass());
 
   return blink::WebNavigationPolicyIgnore;
 }
 
 void HTMLDocument::didAddMessageToConsole(
     const blink::WebConsoleMessage& message,
     const blink::WebString& source_name,
     unsigned source_line,
     const blink::WebString& stack_trace) {
 }
@@ skipping 11 matching lines @@
   DCHECK_EQ(view, root_);
   web_view_->resize(
       blink::WebSize(view->bounds().width, view->bounds().height));
 }
 
 void HTMLDocument::OnViewDestroyed(View* view) {
   DCHECK_EQ(view, root_);
   root_ = nullptr;
 }
 
-void HTMLDocument::OnViewInputEvent(View* view, const EventPtr& event) {
+void HTMLDocument::OnViewInputEvent(View* view, const mojo::EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent>>();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
-}  // namespace mojo
+}  // namespace html_viewer