Removed local RefPtr objects created from PassRefPtr arguments.

third_party/WebKit/Source/platform/network/NetworkStateNotifier.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 140 matching lines @@
         BLINK_FROM_HERE,
         CrossThreadBind(&NetworkStateNotifier::NotifyObserversOnTaskRunner,
                         CrossThreadUnretained(this),
                         CrossThreadUnretained(&map), type, task_runner, state));
   }
 }
 
 void NetworkStateNotifier::NotifyObserversOnTaskRunner(
     ObserverListMap* map,
     ObserverType type,
-    PassRefPtr<WebTaskRunner> pass_task_runner,
+    RefPtr<WebTaskRunner> task_runner,
     const NetworkState& state) {
-  RefPtr<WebTaskRunner> task_runner = pass_task_runner;
   ObserverList* observer_list = LockAndFindObserverList(*map, task_runner);
 
   // The context could have been removed before the notification task got to
   // run.
   if (!observer_list)
     return;
 
   DCHECK(task_runner->RunsTasksOnCurrentThread());
 
   observer_list->iterating = true;
@@ skipping 10 matching lines @@
         observer_list->observers[i]->ConnectionChange(state.type,
                                                       state.max_bandwidth_mbps);
         continue;
     }
     NOTREACHED();
   }
 
   observer_list->iterating = false;
 
   if (!observer_list->zeroed_observers.IsEmpty())
-    CollectZeroedObservers(*map, observer_list, task_runner);
+    CollectZeroedObservers(*map, observer_list, std::move(task_runner));
 }
 
 void NetworkStateNotifier::AddObserver(ObserverListMap& map,
                                        NetworkStateObserver* observer,
                                        PassRefPtr<WebTaskRunner> task_runner) {
   DCHECK(task_runner->RunsTasksOnCurrentThread());
   DCHECK(observer);
 
   MutexLocker locker(mutex_);
   ObserverListMap::AddResult result =
       map.insert(std::move(task_runner), nullptr);
   if (result.is_new_entry)
     result.stored_value->value = WTF::MakeUnique<ObserverList>();
 
   DCHECK(result.stored_value->value->observers.Find(observer) == kNotFound);
   result.stored_value->value->observers.push_back(observer);
 }
 
-void NetworkStateNotifier::RemoveObserver(
-    ObserverListMap& map,
-    NetworkStateObserver* observer,
-    PassRefPtr<WebTaskRunner> pass_task_runner) {
-  RefPtr<WebTaskRunner> task_runner = pass_task_runner;
+void NetworkStateNotifier::RemoveObserver(ObserverListMap& map,
+                                          NetworkStateObserver* observer,
+                                          RefPtr<WebTaskRunner> task_runner) {
   DCHECK(task_runner->RunsTasksOnCurrentThread());
   DCHECK(observer);
 
   ObserverList* observer_list = LockAndFindObserverList(map, task_runner);
   if (!observer_list)
     return;
 
   Vector<NetworkStateObserver*>& observers = observer_list->observers;
   size_t index = observers.Find(observer);
   if (index != kNotFound) {
     observers[index] = 0;
     observer_list->zeroed_observers.push_back(index);
   }
 
   if (!observer_list->iterating && !observer_list->zeroed_observers.IsEmpty())
-    CollectZeroedObservers(map, observer_list, task_runner);
+    CollectZeroedObservers(map, observer_list, std::move(task_runner));
 }
 
 NetworkStateNotifier::ObserverList*
 NetworkStateNotifier::LockAndFindObserverList(
     ObserverListMap& map,
     PassRefPtr<WebTaskRunner> task_runner) {
   MutexLocker locker(mutex_);
   ObserverListMap::iterator it = map.Find(task_runner);
   return it == map.end() ? nullptr : it->value.get();
 }
@@ skipping 12 matching lines @@
 
   list->zeroed_observers.Clear();
 
   if (list->observers.IsEmpty()) {
     MutexLocker locker(mutex_);
     map.erase(task_runner);  // deletes list
   }
 }
 
 }  // namespace blink