Coverity: Remove default TabCaptureRequest constructor.

chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc

 // Copyright (c) 2012 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/extensions/api/tab_capture/tab_capture_registry.h"
 
+#include <utility>
+
 #include "content/public/browser/browser_thread.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/media/media_internals.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 namespace events = extensions::event_names;
 using content::BrowserThread;
 
 namespace extensions {
 
+TabCaptureRegistry::TabCaptureRequest::TabCaptureRequest(
+    std::string extension_id, int tab_id, tab_capture::TabCaptureState status)
+    : extension_id(extension_id), tab_id(tab_id), status(status) {
+}
+
+TabCaptureRegistry::TabCaptureRequest::~TabCaptureRequest() {
+}
+
 TabCaptureRegistry::TabCaptureRegistry(Profile* profile)
     : proxy_(new MediaObserverProxy()), profile_(profile) {
   proxy_->Attach(this);
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 }
 
 TabCaptureRegistry::~TabCaptureRegistry() {
   proxy_->Detach();
 }
 
 void TabCaptureRegistry::HandleRequestUpdateOnUIThread(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevice& device,
     const content::MediaRequestState new_state) {
   EventRouter* router = profile_ ?
       extensions::ExtensionSystem::Get(profile_)->event_router() : NULL;
   if (!router)
     return;
 
   std::pair<int, int> key = std::make_pair(render_process_id, render_view_id);
 
-  if (requests_.find(key) == requests_.end()) {
+  DeviceCaptureRequestMap::iterator request_it = requests_.find(key);
+  if (request_it == requests_.end()) {
     LOG(ERROR) << "Receiving updates for invalid tab capture request.";
     return;
   }
 
   tab_capture::TabCaptureState state =
       tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE;
   switch (new_state) {
     case content::MEDIA_REQUEST_STATE_REQUESTED:
       state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_REQUESTED;
       break;
@@ skipping 12 matching lines @@
     default:
       // TODO(justinlin): Implement muted state notification.
       break;
   }
 
   if (state == tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE) {
     // This is a state we don't handle.
     return;
   }
 
-  TabCaptureRegistry::TabCaptureRequest& request_info = requests_[key];
-  request_info.status = state;
+  TabCaptureRegistry::TabCaptureRequest* request_info = &request_it->second;
+  request_info->status = state;
 
   scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo());
-  info->tab_id = request_info.tab_id;
-  info->status = request_info.status;
+  info->tab_id = request_info->tab_id;
+  info->status = request_info->status;
 
   scoped_ptr<base::ListValue> args(new ListValue());
   args->Append(info->ToValue().release());
   scoped_ptr<Event> event(new Event(
       events::kOnTabCaptureStatusChanged, args.Pass()));
   event->restrict_to_profile = profile_;
-  router->DispatchEventToExtension(request_info.extension_id, event.Pass());
+  router->DispatchEventToExtension(request_info->extension_id, event.Pass());
 }
 
 const TabCaptureRegistry::CaptureRequestList
     TabCaptureRegistry::GetCapturedTabs(const std::string& extension_id) {
   CaptureRequestList list;
   for (DeviceCaptureRequestMap::iterator it = requests_.begin();
        it != requests_.end(); ++it) {
     if (it->second.extension_id == extension_id) {
       list.push_back(it->second);
     }
@@ skipping 20 matching lines @@
         }
       }
       break;
     }
   }
 }
 
 bool TabCaptureRegistry::AddRequest(const std::pair<int, int> key,
                                     const TabCaptureRequest& request) {
   // Currently, we do not allow multiple active captures for same tab.
-  if (requests_.find(key) != requests_.end())
-    if (requests_[key].status !=
-        tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED &&
-        requests_[key].status !=
-        tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR)
+  DeviceCaptureRequestMap::iterator it = requests_.find(key);
+  if (it != requests_.end()) {
+    const tab_capture::TabCaptureState state = it->second.status;
+    if (state != tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED &&
+        state != tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR)
       return false;
-  requests_[key] = request;
+  }
+  requests_.insert(std::make_pair(key, request));
   return true;
 }
 
 bool TabCaptureRegistry::VerifyRequest(int render_process_id,
                                        int render_view_id) {
   return requests_.find(std::make_pair(
       render_process_id, render_view_id)) != requests_.end();
 }
 
 void TabCaptureRegistry::MediaObserverProxy::Attach(
@@ skipping 47 matching lines @@
     const content::MediaStreamDevice& device,
     const content::MediaRequestState new_state) {
   if (handler_)
     handler_->HandleRequestUpdateOnUIThread(render_process_id,
                                             render_view_id,
                                             device,
                                             new_state);
 }
 
 }  // namespace extensions