Remove unnecessary "extensions::" prefix in guest_view/web_view/app_view directories.

chrome/browser/guest_view/app_view/app_view_guest.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 "chrome/browser/guest_view/app_view/app_view_guest.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/guest_view/app_view/app_view_constants.h"
@@ skipping 17 matching lines @@
 
 using content::RenderFrameHost;
 using content::WebContents;
 using extensions::ExtensionHost;
 
 namespace extensions {
 
 namespace {
 
 struct ResponseInfo {
-  scoped_refptr<const extensions::Extension> guest_extension;
+  scoped_refptr<const Extension> guest_extension;
   base::WeakPtr<AppViewGuest> app_view_guest;
   GuestViewBase::WebContentsCreatedCallback callback;
 
-  ResponseInfo(const extensions::Extension* guest_extension,
+  ResponseInfo(const Extension* guest_extension,
                const base::WeakPtr<AppViewGuest>& app_view_guest,
                const GuestViewBase::WebContentsCreatedCallback& callback)
       : guest_extension(guest_extension),
         app_view_guest(app_view_guest),
         callback(callback) {}
 
   ~ResponseInfo() {}
 };
 
 typedef std::map<int, linked_ptr<ResponseInfo> > PendingResponseMap;
@@ skipping 48 matching lines @@
 
 AppViewGuest::AppViewGuest(content::BrowserContext* browser_context,
                            int guest_instance_id)
     : GuestView<AppViewGuest>(browser_context, guest_instance_id),
       weak_ptr_factory_(this) {
 }
 
 AppViewGuest::~AppViewGuest() {
 }
 
-extensions::WindowController* AppViewGuest::GetExtensionWindowController()
-    const {
+WindowController* AppViewGuest::GetExtensionWindowController() const {
   return NULL;
 }
 
 content::WebContents* AppViewGuest::GetAssociatedWebContents() const {
   return guest_web_contents();
 }
 
 bool AppViewGuest::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AppViewGuest, message)
@@ skipping 23 matching lines @@
     int embedder_render_process_id,
     const base::DictionaryValue& create_params,
     const WebContentsCreatedCallback& callback) {
   std::string app_id;
   if (!create_params.GetString(appview::kAppID, &app_id)) {
     callback.Run(NULL);
     return;
   }
 
   ExtensionService* service =
-      extensions::ExtensionSystem::Get(browser_context())->extension_service();
-  const extensions::Extension* guest_extension =
-      service->GetExtensionById(app_id, false);
-  const extensions::Extension* embedder_extension =
+      ExtensionSystem::Get(browser_context())->extension_service();
+  const Extension* guest_extension = service->GetExtensionById(app_id, false);
+  const Extension* embedder_extension =
       service->GetExtensionById(embedder_extension_id, false);
 
   if (!guest_extension || !guest_extension->is_platform_app() ||
       !embedder_extension | !embedder_extension->is_platform_app()) {
     callback.Run(NULL);
     return;
   }
 
   pending_response_map.Get().insert(
       std::make_pair(GetGuestInstanceID(),
                      make_linked_ptr(new ResponseInfo(
                                         guest_extension,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         callback))));
 
-  extensions::LazyBackgroundTaskQueue* queue =
-      extensions::ExtensionSystem::Get(browser_context())->
-          lazy_background_task_queue();
+  LazyBackgroundTaskQueue* queue =
+      ExtensionSystem::Get(browser_context())->lazy_background_task_queue();
   if (queue->ShouldEnqueueTask(browser_context(), guest_extension)) {
     queue->AddPendingTask(browser_context(),
                           guest_extension->id(),
                           base::Bind(&AppViewGuest::LaunchAppAndFireEvent,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      callback));
     return;
   }
 
-  extensions::ProcessManager* process_manager =
-      extensions::ExtensionSystem::Get(browser_context())->process_manager();
+  ProcessManager* process_manager =
+      ExtensionSystem::Get(browser_context())->process_manager();
   ExtensionHost* host =
       process_manager->GetBackgroundHostForExtension(guest_extension->id());
   DCHECK(host);
   LaunchAppAndFireEvent(callback, host);
 }
 
 void AppViewGuest::DidAttachToEmbedder() {
   // This is called after the guest process has been attached to a host
   // element. This means that the host element knows how to route input
   // events to the guest, and the guest knows how to get frames to the
   // embedder.
   guest_web_contents()->GetController().LoadURL(
       url_, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
 }
 
 void AppViewGuest::DidInitialize() {
   extension_function_dispatcher_.reset(
-      new extensions::ExtensionFunctionDispatcher(browser_context(), this));
+      new ExtensionFunctionDispatcher(browser_context(), this));
 }
 
 void AppViewGuest::OnRequest(const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_->Dispatch(
       params, guest_web_contents()->GetRenderViewHost());
 }
 
 void AppViewGuest::CompleteCreateWebContents(
     const GURL& url,
-    const extensions::Extension* guest_extension,
+    const Extension* guest_extension,
     const WebContentsCreatedCallback& callback) {
   if (!url.is_valid()) {
     callback.Run(NULL);
     return;
   }
   url_ = url;
   guest_extension_id_ = guest_extension->id();
 
   WebContents::CreateParams params(
       browser_context(),
       content::SiteInstance::CreateForURL(browser_context(),
                                           guest_extension->url()));
   params.guest_delegate = this;
   callback.Run(WebContents::Create(params));
 }
 
 void AppViewGuest::LaunchAppAndFireEvent(
     const WebContentsCreatedCallback& callback,
     ExtensionHost* extension_host) {
-  extensions::ExtensionSystem* system =
-      extensions::ExtensionSystem::Get(browser_context());
+  ExtensionSystem* system = ExtensionSystem::Get(browser_context());
   bool has_event_listener = system->event_router()->ExtensionHasEventListener(
       extension_host->extension()->id(),
       app_runtime::OnEmbedRequested::kEventName);
   if (!has_event_listener) {
     callback.Run(NULL);
     return;
   }
 
   scoped_ptr<base::DictionaryValue> embed_request(new base::DictionaryValue());
   embed_request->SetInteger(appview::kGuestInstanceID, GetGuestInstanceID());
   embed_request->SetString(appview::kEmbedderID, embedder_extension_id());
-  extensions::AppRuntimeEventRouter::DispatchOnEmbedRequestedEvent(
+  AppRuntimeEventRouter::DispatchOnEmbedRequestedEvent(
       browser_context(), embed_request.Pass(), extension_host->extension());
 }
 
 }  // namespace extensions