Stamp out CreateStringValue in chrome/

chrome/browser/guest_view/web_view/web_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/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 736 matching lines @@
   // Chromium's repost warning. We might want to implement a separate API
   // for registering a callback if a repost is about to happen.
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::RequestFileSystemPermission(
     const GURL& url,
     bool allowed_by_default,
     const base::Callback<void(bool)>& callback) {
   base::DictionaryValue request_info;
-  request_info.Set(guestview::kUrl, base::Value::CreateStringValue(url.spec()));
+  request_info.Set(guestview::kUrl, new base::StringValue(url.spec()));
   RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_FILESYSTEM,
       request_info,
       base::Bind(&WebViewGuest::OnWebViewFileSystemPermissionResponse,
                  base::Unretained(this),
                  callback),
       allowed_by_default);
 }
 
 void WebViewGuest::OnWebViewFileSystemPermissionResponse(
     const base::Callback<void(bool)>& callback,
     bool allow,
     const std::string& user_input) {
   callback.Run(allow && attached());
 }
 
 void WebViewGuest::RequestGeolocationPermission(
     int bridge_id,
     const GURL& requesting_frame,
     bool user_gesture,
     const base::Callback<void(bool)>& callback) {
   base::DictionaryValue request_info;
   request_info.Set(guestview::kUrl,
-                   base::Value::CreateStringValue(requesting_frame.spec()));
+                   new base::StringValue(requesting_frame.spec()));
   request_info.Set(guestview::kUserGesture,
                    base::Value::CreateBooleanValue(user_gesture));
 
   // It is safe to hold an unretained pointer to WebViewGuest because this
   // callback is called from WebViewGuest::SetPermission.
   const PermissionResponseCallback permission_callback =
       base::Bind(&WebViewGuest::OnWebViewGeolocationPermissionResponse,
                  base::Unretained(this),
                  bridge_id,
                  user_gesture,
@@ skipping 411 matching lines @@
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
     content::WebContents* source,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   base::DictionaryValue request_info;
-  request_info.Set(
-      guestview::kUrl,
-      base::Value::CreateStringValue(request.security_origin.spec()));
+  request_info.Set(guestview::kUrl,
+                   new base::StringValue(request.security_origin.spec()));
   RequestPermission(WEB_VIEW_PERMISSION_TYPE_MEDIA,
                     request_info,
                     base::Bind(&WebViewGuest::OnWebViewMediaPermissionResponse,
                                base::Unretained(this),
                                request,
                                callback),
                     false /* allowed_by_default */);
 }
 
 void WebViewGuest::CanDownload(
     content::RenderViewHost* render_view_host,
     const GURL& url,
     const std::string& request_method,
     const base::Callback<void(bool)>& callback) {
   base::DictionaryValue request_info;
-  request_info.Set(
-      guestview::kUrl,
-      base::Value::CreateStringValue(url.spec()));
+  request_info.Set(guestview::kUrl, new base::StringValue(url.spec()));
   RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_DOWNLOAD,
       request_info,
       base::Bind(&WebViewGuest::OnWebViewDownloadPermissionResponse,
                  base::Unretained(this),
                  callback),
       false /* allowed_by_default */);
 }
 
 void WebViewGuest::RequestPointerLockPermission(
     bool user_gesture,
     bool last_unlocked_by_target,
     const base::Callback<void(bool)>& callback) {
   base::DictionaryValue request_info;
   request_info.Set(guestview::kUserGesture,
                    base::Value::CreateBooleanValue(user_gesture));
   request_info.Set(webview::kLastUnlockedBySelf,
                    base::Value::CreateBooleanValue(last_unlocked_by_target));
   request_info.Set(guestview::kUrl,
-                   base::Value::CreateStringValue(
+                   new base::StringValue(
                        guest_web_contents()->GetLastCommittedURL().spec()));
 
   RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK,
       request_info,
       base::Bind(&WebViewGuest::OnWebViewPointerLockPermissionResponse,
                  base::Unretained(this),
                  callback),
       false /* allowed_by_default */);
 }
@@ skipping 335 matching lines @@
   // Retrieve the opener partition info if we have it.
   const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL();
   std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url);
 
   base::DictionaryValue request_info;
   request_info.Set(webview::kInitialHeight,
                    base::Value::CreateIntegerValue(initial_bounds.height()));
   request_info.Set(webview::kInitialWidth,
                    base::Value::CreateIntegerValue(initial_bounds.width()));
   request_info.Set(webview::kTargetURL,
-                   base::Value::CreateStringValue(new_window_info.url.spec()));
-  request_info.Set(webview::kName,
-                   base::Value::CreateStringValue(new_window_info.name));
+                   new base::StringValue(new_window_info.url.spec()));
+  request_info.Set(webview::kName, new base::StringValue(new_window_info.name));
   request_info.Set(webview::kWindowID,
                    base::Value::CreateIntegerValue(
                       guest->GetGuestInstanceID()));
   // We pass in partition info so that window-s created through newwindow
   // API can use it to set their partition attribute.
   request_info.Set(webview::kStoragePartitionId,
-                   base::Value::CreateStringValue(storage_partition_id));
-  request_info.Set(webview::kWindowOpenDisposition,
-                   base::Value::CreateStringValue(
-                       WindowOpenDispositionToString(disposition)));
+                   new base::StringValue(storage_partition_id));
+  request_info.Set(
+      webview::kWindowOpenDisposition,
+      new base::StringValue(WindowOpenDispositionToString(disposition)));
 
   RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
                     request_info,
                     base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
                                base::Unretained(this),
                                guest->GetGuestInstanceID()),
                                false /* allowed_by_default */);
 }
 
 void WebViewGuest::DestroyUnattachedWindows() {
@@ skipping 28 matching lines @@
     bool allow,
     const std::string& user_input) {
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }