Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/guestview/webview/webview_guest.cc

 // Copyright 2013 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/guestview/webview/webview_guest.h"
 
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
@@ skipping 254 matching lines @@
 }
 
 AdViewGuest* WebViewGuest::AsAdView() {
   return NULL;
 }
 
 void WebViewGuest::AddMessageToConsole(int32 level,
                                        const base::string16& message,
                                        int32 line_no,
                                        const base::string16& source_id) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   // Log levels are from base/logging.h: LogSeverity.
   args->SetInteger(webview::kLevel, level);
   args->SetString(webview::kMessage, message);
   args->SetInteger(webview::kLine, line_no);
   args->SetString(webview::kSourceId, source_id);
   DispatchEvent(
       new GuestView::Event(webview::kEventConsoleMessage, args.Pass()));
 }
 
 void WebViewGuest::Close() {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestView::Event(webview::kEventClose, args.Pass()));
 }
 
 void WebViewGuest::DidAttach() {
   if (pending_reload_on_attachment_) {
     pending_reload_on_attachment_ = false;
     guest_web_contents()->GetController().Reload(false);
   }
 }
 
 void WebViewGuest::EmbedderDestroyed() {
   // TODO(fsamuel): WebRequest event listeners for <webview> should survive
   // reparenting of a <webview> within a single embedder. Right now, we keep
   // around the browser state for the listener for the lifetime of the embedder.
   // Ideally, the lifetime of the listeners should match the lifetime of the
   // <webview> DOM node. Once http://crbug.com/156219 is resolved we can move
   // the call to RemoveWebViewEventListenersOnIOThread back to
   // WebViewGuest::WebContentsDestroyed.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context(), extension_id(),
           embedder_render_process_id(),
           view_instance_id()));
 }
 
 void WebViewGuest::GuestProcessGone(base::TerminationStatus status) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
   DispatchEvent(
       new GuestView::Event(webview::kEventExit, args.Pass()));
 }
 
 bool WebViewGuest::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   if (event.type != blink::WebInputEvent::RawKeyDown)
@@ skipping 40 matching lines @@
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserPluginDragDrop);
 #endif
 }
 
 bool WebViewGuest::IsOverridingUserAgent() const {
   return is_overriding_user_agent_;
 }
 
 void WebViewGuest::LoadProgressed(double progress) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
   DispatchEvent(new GuestView::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
   args->SetString(guestview::kReason, error_type);
   DispatchEvent(new GuestView::Event(webview::kEventLoadAbort, args.Pass()));
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
 void WebViewGuest::RendererResponsive() {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(new GuestView::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive() {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(new GuestView::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 bool WebViewGuest::RequestPermission(
     BrowserPluginPermissionType permission_type,
     const base::DictionaryValue& request_info,
     const PermissionResponseCallback& callback,
     bool allowed_by_default) {
@@ skipping 149 matching lines @@
 WebViewGuest::~WebViewGuest() {
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     int64 frame_id,
     const base::string16& frame_unique_name,
     bool is_main_frame,
     const GURL& url,
     content::PageTransition transition_type,
     content::RenderViewHost* render_view_host) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, url.spec());
   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
   args->SetInteger(webview::kInternalCurrentEntryIndex,
       web_contents()->GetController().GetCurrentEntryIndex());
   args->SetInteger(webview::kInternalEntryCount,
       web_contents()->GetController().GetEntryCount());
   args->SetInteger(webview::kInternalProcessId,
       web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(new GuestView::Event(webview::kEventLoadCommit, args.Pass()));
 }
@@ skipping 13 matching lines @@
 }
 
 void WebViewGuest::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     int64 parent_frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc,
     content::RenderViewHost* render_view_host) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, validated_url.spec());
   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
   DispatchEvent(new GuestView::Event(webview::kEventLoadStart, args.Pass()));
 }
 
 void WebViewGuest::DidStopLoading(content::RenderViewHost* render_view_host) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestView::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::WebContentsDestroyed(WebContents* web_contents) {
   RemoveWebViewFromExtensionRendererState(web_contents);
 }
 
 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
   content::NavigationController& controller =
       guest_web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetVisibleEntry();
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
   if (!attached()) {
     // We cannot reload now because all resource loads are suspended until
     // attachment.
     pending_reload_on_attachment_ = true;
     return;
   }
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::LoadHandlerCalled() {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestView::Event(webview::kEventContentLoad, args.Pass()));
 }
 
 void WebViewGuest::LoadRedirect(const GURL& old_url,
                                 const GURL& new_url,
                                 bool is_top_level) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(webview::kNewURL, new_url.spec());
   args->SetString(webview::kOldURL, old_url.spec());
   DispatchEvent(new GuestView::Event(webview::kEventLoadRedirect, args.Pass()));
 }
 
 // static
 bool WebViewGuest::AllowChromeExtensionURLs() {
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   return channel <= chrome::VersionInfo::CHANNEL_DEV;
@@ skipping 51 matching lines @@
     return GURL(src);
 
   GURL default_url(base::StringPrintf("%s://%s/",
                                       extensions::kExtensionScheme,
                                       extension_id().c_str()));
   return default_url.Resolve(src);
 }
 
 void WebViewGuest::SizeChanged(const gfx::Size& old_size,
                                const gfx::Size& new_size) {
-  scoped_ptr<DictionaryValue> args(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEvent(new GuestView::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
     : permission_type(BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN),
       allowed_by_default(false) {
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
     const PermissionResponseCallback& callback,
     BrowserPluginPermissionType permission_type,
     bool allowed_by_default)
     : callback(callback),
       permission_type(permission_type),
       allowed_by_default(allowed_by_default) {
 }
 
 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
 }