Overhaul JSON Schema Compiler to support a number of features required to

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"
@@ skipping 42 matching lines @@
     return;
 
   std::pair<int, int> key = std::make_pair(render_process_id, render_view_id);
 
   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;
+  tab_capture::TabCaptureState state = tab_capture::TAB_CAPTURE_STATE_NONE;
   switch (new_state) {
     case content::MEDIA_REQUEST_STATE_REQUESTED:
-      state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_REQUESTED;
+      state = tab_capture::TAB_CAPTURE_STATE_REQUESTED;
       break;
     case content::MEDIA_REQUEST_STATE_PENDING_APPROVAL:
-      state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_PENDING;
+      state = tab_capture::TAB_CAPTURE_STATE_PENDING;
       break;
     case content::MEDIA_REQUEST_STATE_DONE:
-      state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ACTIVE;
+      state = tab_capture::TAB_CAPTURE_STATE_ACTIVE;
       break;
     case content::MEDIA_REQUEST_STATE_CLOSING:
-      state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED;
+      state = tab_capture::TAB_CAPTURE_STATE_STOPPED;
       break;
     case content::MEDIA_REQUEST_STATE_ERROR:
-      state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR;
+      state = tab_capture::TAB_CAPTURE_STATE_ERROR;
       break;
     default:
       // TODO(justinlin): Implement muted state notification.
       break;
   }
 
-  if (state == tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE) {
+  if (state == tab_capture::TAB_CAPTURE_STATE_NONE) {
     // This is a state we don't handle.
     return;
   }
 
   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;
@@ skipping 40 matching lines @@
     }
   }
 }
 
 bool TabCaptureRegistry::AddRequest(const std::pair<int, int> key,
                                     const TabCaptureRequest& request) {
   // Currently, we do not allow multiple active captures for same tab.
   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)
+    if (state != tab_capture::TAB_CAPTURE_STATE_STOPPED &&
+        state != tab_capture::TAB_CAPTURE_STATE_ERROR)
       return false;
   }
   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();
@@ skipping 50 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