Remove webrtc/libjingle/{examples,session}.

webrtc/libjingle/session/media/mediamessages.cc

-/*
- * libjingle
- * Copyright 2010 Google Inc.
- *
- * 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 documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * Documentation is in mediamessages.h.
- */
-
-#include "webrtc/libjingle/session/media/mediamessages.h"
-
-#include "webrtc/p2p/base/constants.h"
-#include "webrtc/libjingle/session/media/mediasessionclient.h"
-#include "webrtc/libjingle/xmllite/xmlelement.h"
-#include "webrtc/base/logging.h"
-#include "webrtc/base/stringencode.h"
-
-namespace cricket {
-
-namespace {
-
-bool ParseSsrc(const std::string& string, uint32* ssrc) {
-  return rtc::FromString(string, ssrc);
-}
-
-// Builds a <view> element according to the following spec:
-// goto/jinglemuc
-buzz::XmlElement* CreateViewElem(const std::string& name,
-                                 const std::string& type) {
-  buzz::XmlElement* view_elem =
-      new buzz::XmlElement(QN_JINGLE_DRAFT_VIEW, true);
-  view_elem->AddAttr(QN_NAME, name);
-  view_elem->SetAttr(QN_TYPE, type);
-  return view_elem;
-}
-
-buzz::XmlElement* CreateVideoViewElem(const std::string& content_name,
-                                      const std::string& type) {
-  return CreateViewElem(content_name, type);
-}
-
-buzz::XmlElement* CreateNoneVideoViewElem(const std::string& content_name) {
-  return CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_NONE);
-}
-
-buzz::XmlElement* CreateStaticVideoViewElem(const std::string& content_name,
-                                            const StaticVideoView& view) {
-  buzz::XmlElement* view_elem =
-      CreateVideoViewElem(content_name, STR_JINGLE_DRAFT_VIEW_TYPE_STATIC);
-  AddXmlAttr(view_elem, QN_SSRC, view.selector.ssrc);
-
-  buzz::XmlElement* params_elem = new buzz::XmlElement(QN_JINGLE_DRAFT_PARAMS);
-  AddXmlAttr(params_elem, QN_WIDTH, view.width);
-  AddXmlAttr(params_elem, QN_HEIGHT, view.height);
-  AddXmlAttr(params_elem, QN_FRAMERATE, view.framerate);
-  AddXmlAttr(params_elem, QN_PREFERENCE, view.preference);
-  view_elem->AddElement(params_elem);
-
-  return view_elem;
-}
-
-}  //  namespace
-
-bool IsJingleViewRequest(const buzz::XmlElement* action_elem) {
-  return action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW) != NULL;
-}
-
-bool ParseStaticVideoView(const buzz::XmlElement* view_elem,
-                          StaticVideoView* view,
-                          ParseError* error) {
-  uint32 ssrc;
-  if (!ParseSsrc(view_elem->Attr(QN_SSRC), &ssrc)) {
-    return BadParse("Invalid or missing view ssrc.", error);
-  }
-  view->selector = StreamSelector(ssrc);
-
-  const buzz::XmlElement* params_elem =
-      view_elem->FirstNamed(QN_JINGLE_DRAFT_PARAMS);
-  if (params_elem) {
-    view->width = GetXmlAttr(params_elem, QN_WIDTH, 0);
-    view->height = GetXmlAttr(params_elem, QN_HEIGHT, 0);
-    view->framerate = GetXmlAttr(params_elem, QN_FRAMERATE, 0);
-    view->preference = GetXmlAttr(params_elem, QN_PREFERENCE, 0);
-  } else {
-    return BadParse("Missing view params.", error);
-  }
-
-  return true;
-}
-
-bool ParseJingleViewRequest(const buzz::XmlElement* action_elem,
-                            ViewRequest* view_request,
-                            ParseError* error) {
-  for (const buzz::XmlElement* view_elem =
-           action_elem->FirstNamed(QN_JINGLE_DRAFT_VIEW);
-       view_elem != NULL;
-       view_elem = view_elem->NextNamed(QN_JINGLE_DRAFT_VIEW)) {
-    std::string type = view_elem->Attr(QN_TYPE);
-    if (STR_JINGLE_DRAFT_VIEW_TYPE_NONE == type) {
-      view_request->static_video_views.clear();
-      return true;
-    } else if (STR_JINGLE_DRAFT_VIEW_TYPE_STATIC == type) {
-      StaticVideoView static_video_view(StreamSelector(0), 0, 0, 0);
-      if (!ParseStaticVideoView(view_elem, &static_video_view, error)) {
-        return false;
-      }
-      view_request->static_video_views.push_back(static_video_view);
-    } else {
-      LOG(LS_INFO) << "Ingnoring unknown view type: " << type;
-    }
-  }
-  return true;
-}
-
-bool WriteJingleViewRequest(const std::string& content_name,
-                            const ViewRequest& request,
-                            XmlElements* elems,
-                            WriteError* error) {
-  if (request.static_video_views.empty()) {
-    elems->push_back(CreateNoneVideoViewElem(content_name));
-  } else {
-    for (StaticVideoViews::const_iterator view =
-             request.static_video_views.begin();
-         view != request.static_video_views.end(); ++view) {
-      elems->push_back(CreateStaticVideoViewElem(content_name, *view));
-    }
-  }
-  return true;
-}
-
-bool ParseSsrcAsLegacyStream(const buzz::XmlElement* desc_elem,
-                             std::vector<StreamParams>* streams,
-                             ParseError* error) {
-  const std::string ssrc_str = desc_elem->Attr(QN_SSRC);
-  if (!ssrc_str.empty()) {
-    uint32 ssrc;
-    if (!ParseSsrc(ssrc_str, &ssrc)) {
-      return BadParse("Missing or invalid ssrc.", error);
-    }
-
-    streams->push_back(StreamParams::CreateLegacy(ssrc));
-  }
-  return true;
-}
-
-bool ParseSsrcs(const buzz::XmlElement* parent_elem,
-                std::vector<uint32>* ssrcs,
-                ParseError* error) {
-  for (const buzz::XmlElement* ssrc_elem =
-           parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC);
-       ssrc_elem != NULL;
-       ssrc_elem = ssrc_elem->NextNamed(QN_JINGLE_DRAFT_SSRC)) {
-    uint32 ssrc;
-    if (!ParseSsrc(ssrc_elem->BodyText(), &ssrc)) {
-      return BadParse("Missing or invalid ssrc.", error);
-    }
-
-    ssrcs->push_back(ssrc);
-  }
-  return true;
-}
-
-bool ParseSsrcGroups(const buzz::XmlElement* parent_elem,
-                     std::vector<SsrcGroup>* ssrc_groups,
-                     ParseError* error) {
-  for (const buzz::XmlElement* group_elem =
-           parent_elem->FirstNamed(QN_JINGLE_DRAFT_SSRC_GROUP);
-       group_elem != NULL;
-       group_elem = group_elem->NextNamed(QN_JINGLE_DRAFT_SSRC_GROUP)) {
-    std::string semantics = group_elem->Attr(QN_SEMANTICS);
-    std::vector<uint32> ssrcs;
-    if (!ParseSsrcs(group_elem, &ssrcs, error)) {
-      return false;
-    }
-    ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
-  }
-  return true;
-}
-
-bool ParseJingleStream(const buzz::XmlElement* stream_elem,
-                       std::vector<StreamParams>* streams,
-                       ParseError* error) {
-  StreamParams stream;
-  // We treat the nick as a stream groupid.
-  stream.groupid = stream_elem->Attr(QN_NICK);
-  stream.id = stream_elem->Attr(QN_NAME);
-  stream.type = stream_elem->Attr(QN_TYPE);
-  stream.display = stream_elem->Attr(QN_DISPLAY);
-  stream.cname = stream_elem->Attr(QN_CNAME);
-  if (!ParseSsrcs(stream_elem, &(stream.ssrcs), error)) {
-    return false;
-  }
-  std::vector<SsrcGroup> ssrc_groups;
-  if (!ParseSsrcGroups(stream_elem, &(stream.ssrc_groups), error)) {
-    return false;
-  }
-  streams->push_back(stream);
-  return true;
-}
-
-bool ParseJingleRtpHeaderExtensions(const buzz::XmlElement* parent_elem,
-                                    std::vector<RtpHeaderExtension>* hdrexts,
-                                    ParseError* error) {
-  for (const buzz::XmlElement* hdrext_elem =
-           parent_elem->FirstNamed(QN_JINGLE_RTP_HDREXT);
-       hdrext_elem != NULL;
-       hdrext_elem = hdrext_elem->NextNamed(QN_JINGLE_RTP_HDREXT)) {
-    std::string uri = hdrext_elem->Attr(QN_URI);
-    int id = GetXmlAttr(hdrext_elem, QN_ID, 0);
-    if (id <= 0) {
-      return BadParse("Invalid RTP header extension id.", error);
-    }
-    hdrexts->push_back(RtpHeaderExtension(uri, id));
-  }
-  return true;
-}
-
-bool HasJingleStreams(const buzz::XmlElement* desc_elem) {
-  const buzz::XmlElement* streams_elem =
-      desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
-  return (streams_elem != NULL);
-}
-
-bool ParseJingleStreams(const buzz::XmlElement* desc_elem,
-                        std::vector<StreamParams>* streams,
-                        ParseError* error) {
-  const buzz::XmlElement* streams_elem =
-      desc_elem->FirstNamed(QN_JINGLE_DRAFT_STREAMS);
-  if (streams_elem == NULL) {
-    return BadParse("Missing streams element.", error);
-  }
-  for (const buzz::XmlElement* stream_elem =
-           streams_elem->FirstNamed(QN_JINGLE_DRAFT_STREAM);
-       stream_elem != NULL;
-       stream_elem = stream_elem->NextNamed(QN_JINGLE_DRAFT_STREAM)) {
-    if (!ParseJingleStream(stream_elem, streams, error)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-void WriteSsrcs(const std::vector<uint32>& ssrcs,
-                buzz::XmlElement* parent_elem) {
-  for (std::vector<uint32>::const_iterator ssrc = ssrcs.begin();
-       ssrc != ssrcs.end(); ++ssrc) {
-    buzz::XmlElement* ssrc_elem =
-        new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC, false);
-    SetXmlBody(ssrc_elem, *ssrc);
-
-    parent_elem->AddElement(ssrc_elem);
-  }
-}
-
-void WriteSsrcGroups(const std::vector<SsrcGroup>& groups,
-                     buzz::XmlElement* parent_elem) {
-  for (std::vector<SsrcGroup>::const_iterator group = groups.begin();
-       group != groups.end(); ++group) {
-    buzz::XmlElement* group_elem =
-        new buzz::XmlElement(QN_JINGLE_DRAFT_SSRC_GROUP, false);
-    AddXmlAttrIfNonEmpty(group_elem, QN_SEMANTICS, group->semantics);
-    WriteSsrcs(group->ssrcs, group_elem);
-
-    parent_elem->AddElement(group_elem);
-  }
-}
-
-void WriteJingleStream(const StreamParams& stream,
-                       buzz::XmlElement* parent_elem) {
-  buzz::XmlElement* stream_elem =
-      new buzz::XmlElement(QN_JINGLE_DRAFT_STREAM, false);
-  // We treat the nick as a stream groupid.
-  AddXmlAttrIfNonEmpty(stream_elem, QN_NICK, stream.groupid);
-  AddXmlAttrIfNonEmpty(stream_elem, QN_NAME, stream.id);
-  AddXmlAttrIfNonEmpty(stream_elem, QN_TYPE, stream.type);
-  AddXmlAttrIfNonEmpty(stream_elem, QN_DISPLAY, stream.display);
-  AddXmlAttrIfNonEmpty(stream_elem, QN_CNAME, stream.cname);
-  WriteSsrcs(stream.ssrcs, stream_elem);
-  WriteSsrcGroups(stream.ssrc_groups, stream_elem);
-
-  parent_elem->AddElement(stream_elem);
-}
-
-void WriteJingleStreams(const std::vector<StreamParams>& streams,
-                        buzz::XmlElement* parent_elem) {
-  buzz::XmlElement* streams_elem =
-      new buzz::XmlElement(QN_JINGLE_DRAFT_STREAMS, true);
-  for (std::vector<StreamParams>::const_iterator stream = streams.begin();
-       stream != streams.end(); ++stream) {
-    WriteJingleStream(*stream, streams_elem);
-  }
-
-  parent_elem->AddElement(streams_elem);
-}
-
-void WriteJingleRtpHeaderExtensions(
-    const std::vector<RtpHeaderExtension>& hdrexts,
-    buzz::XmlElement* parent_elem) {
-  for (std::vector<RtpHeaderExtension>::const_iterator hdrext = hdrexts.begin();
-       hdrext != hdrexts.end(); ++hdrext) {
-    buzz::XmlElement* hdrext_elem =
-      new buzz::XmlElement(QN_JINGLE_RTP_HDREXT, false);
-    AddXmlAttr(hdrext_elem, QN_URI, hdrext->uri);
-    AddXmlAttr(hdrext_elem, QN_ID, hdrext->id);
-    parent_elem->AddElement(hdrext_elem);
-  }
-}
-
-
-}  // namespace cricket