Remove linked_ptr usage in //base.

extensions/browser/guest_view/web_view/web_view_find_helper.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 "extensions/browser/guest_view/web_view/web_view_find_helper.h"
 
 #include <utility>
 
 #include "components/guest_view/browser/guest_view_event.h"
 #include "extensions/browser/api/guest_view/web_view/web_view_internal_api.h"
 #include "extensions/browser/guest_view/web_view/web_view_constants.h"
 
 using guest_view::GuestViewEvent;
 
 namespace extensions {
 
 WebViewFindHelper::WebViewFindHelper(WebViewGuest* webview_guest)
     : webview_guest_(webview_guest), current_find_request_id_(0) {
 }
 
 WebViewFindHelper::~WebViewFindHelper() {
 }
 
 void WebViewFindHelper::CancelAllFindSessions() {
-  current_find_session_ = linked_ptr<WebViewFindHelper::FindInfo>();
+  current_find_session_ = nullptr;
   while (!find_info_map_.empty()) {
     find_info_map_.begin()->second->SendResponse(true /* canceled */);
     find_info_map_.erase(find_info_map_.begin());
   }
-  if (find_update_event_.get())
+  if (find_update_event_)
     DispatchFindUpdateEvent(true /* canceled */, true /* final_update */);
   find_update_event_.reset();
 }
 
 void WebViewFindHelper::DispatchFindUpdateEvent(bool canceled,
                                                 bool final_update) {
   DCHECK(find_update_event_.get());
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   find_update_event_->PrepareResults(args.get());
   args->SetBoolean(webview::kFindCanceled, canceled);
   args->SetBoolean(webview::kFindFinalUpdate, final_update);
   DCHECK(webview_guest_);
-  webview_guest_->DispatchEventToView(
-      new GuestViewEvent(webview::kEventFindReply, std::move(args)));
+  webview_guest_->DispatchEventToView(make_scoped_ptr(
+      new GuestViewEvent(webview::kEventFindReply, std::move(args))));
 }
 
 void WebViewFindHelper::EndFindSession(int session_request_id, bool canceled) {
   FindInfoMap::iterator session_iterator =
       find_info_map_.find(session_request_id);
   DCHECK(session_iterator != find_info_map_.end());
   FindInfo* find_info = session_iterator->second.get();
 
   // Call the callback function of the first request of the find session.
   find_info->SendResponse(canceled);
@@ skipping 38 matching lines @@
     const blink::WebFindOptions& options,
     scoped_refptr<WebViewInternalFindFunction> find_function) {
   // Need a new request_id for each new find request.
   ++current_find_request_id_;
 
   // Stores the find request information by request_id so that its callback
   // function can be called when the find results are available.
   std::pair<FindInfoMap::iterator, bool> insert_result =
       find_info_map_.insert(std::make_pair(
           current_find_request_id_,
-          linked_ptr<
-              WebViewFindHelper::FindInfo>(new WebViewFindHelper::FindInfo(
-              current_find_request_id_, search_text, options, find_function))));
+          make_scoped_refptr(new FindInfo(current_find_request_id_, search_text,
+                                          options, find_function))));
   // No duplicate insertions.
   DCHECK(insert_result.second);
 
   // Find options including the implicit |findNext| field.
   blink::WebFindOptions* full_options = insert_result.first->second->options();
 
   // Set |findNext| implicitly.
-  if (current_find_session_.get()) {
+  if (current_find_session_) {
     const base::string16& current_search_text =
         current_find_session_->search_text();
     bool current_match_case = current_find_session_->options()->matchCase;
     full_options->findNext = !current_search_text.empty() &&
         current_search_text == search_text &&
         current_match_case == options.matchCase;
   } else {
     full_options->findNext = false;
   }
 
   // Link find requests that are a part of the same find session.
-  if (full_options->findNext && current_find_session_.get()) {
+  if (full_options->findNext && current_find_session_) {
     DCHECK(current_find_request_id_ != current_find_session_->request_id());
     current_find_session_->AddFindNextRequest(
         insert_result.first->second->AsWeakPtr());
   }
 
   // Update the current find session, if necessary.
   if (!full_options->findNext)
     current_find_session_ = insert_result.first->second;
 
   // Handle the empty |search_text| case internally.
@@ skipping 12 matching lines @@
                                   const gfx::Rect& selection_rect,
                                   int active_match_ordinal,
                                   bool final_update) {
   FindInfoMap::iterator find_iterator = find_info_map_.find(request_id);
 
   // Ignore slow replies to canceled find requests.
   if (find_iterator == find_info_map_.end())
     return;
 
   // This find request must be a part of an existing find session.
-  DCHECK(current_find_session_.get());
+  DCHECK(current_find_session_);
 
   WebViewFindHelper::FindInfo* find_info = find_iterator->second.get();
 
   // Handle canceled find requests.
   if (!find_info->options()->findNext &&
       find_info_map_.begin()->first < request_id) {
     DCHECK_NE(current_find_session_->request_id(),
               find_info_map_.begin()->first);
     DispatchFindUpdateEvent(true /* canceled */, true /* final_update */);
     EndFindSession(find_info_map_.begin()->first, true /* canceled */);
@@ skipping 84 matching lines @@
     const blink::WebFindOptions& options,
     scoped_refptr<WebViewInternalFindFunction> find_function)
     : request_id_(request_id),
       search_text_(search_text),
       options_(options),
       find_function_(find_function),
       replied_(false),
       weak_ptr_factory_(this) {
 }
 
-WebViewFindHelper::FindInfo::~FindInfo() {
-}
-
 void WebViewFindHelper::FindInfo::AggregateResults(
     int number_of_matches,
     const gfx::Rect& selection_rect,
     int active_match_ordinal,
     bool final_update) {
   replied_ = true;
   find_results_.AggregateResults(number_of_matches, selection_rect,
                                  active_match_ordinal, final_update);
 }
 
 base::WeakPtr<WebViewFindHelper::FindInfo>
 WebViewFindHelper::FindInfo::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void WebViewFindHelper::FindInfo::SendResponse(bool canceled) {
   // Prepare the find results to pass to the callback function.
   base::DictionaryValue results;
   find_results_.PrepareResults(&results);
   results.SetBoolean(webview::kFindCanceled, canceled);
 
   // Call the callback.
   find_function_->SetResult(results.DeepCopy());
   find_function_->SendResponse(true);
 }
 
+WebViewFindHelper::FindInfo::~FindInfo() {}
+
 }  // namespace extensions